@adonisjs/auth 8.2.3 → 9.0.0-1

package/build/src/UserProviders/Lucid/index.js

@@ -1,146 +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.LucidProvider = void 0;
-const hooks_1 = require("@poppinss/hooks");
-const utils_1 = require("@poppinss/utils");
-const User_1 = require("./User");
-/**
- * Lucid provider uses Lucid models to lookup a users
- */
-class LucidProvider {
-    constructor(application, config) {
-        this.application = application;
-        this.config = config;
-        /**
-         * Hooks reference
-         */
-        this.hooks = new hooks_1.Hooks();
-    }
-    /**
-     * The models options for constructing a query
-     */
-    getModelOptions() {
-        if (typeof this.connection === 'string') {
-            return { connection: this.connection };
-        }
-        if (this.connection) {
-            return { client: this.connection };
-        }
-        return this.config.connection ? { connection: this.config.connection } : {};
-    }
-    /**
-     * Returns the auth model
-     */
-    async getModel() {
-        const model = await this.config.model();
-        return (0, utils_1.esmResolver)(model);
-    }
-    /**
-     * Returns query instance for the user model
-     */
-    async getModelQuery(model) {
-        model = model || (await this.getModel());
-        return {
-            query: model.query(this.getModelOptions()),
-        };
-    }
-    /**
-     * Executes the query to find the user, calls the registered hooks
-     * and wraps the result inside [[ProviderUserContract]]
-     */
-    async findUser(query) {
-        await this.hooks.exec('before', 'findUser', query);
-        const user = await query.first();
-        if (user) {
-            await this.hooks.exec('after', 'findUser', user);
-        }
-        return this.getUserFor(user);
-    }
-    /**
-     * Returns an instance of the [[ProviderUser]] by wrapping lucid model
-     * inside it
-     */
-    async getUserFor(user) {
-        const UserBuilder = this.config.user ? (0, utils_1.esmResolver)(await this.config.user()) : User_1.LucidUser;
-        return this.application.container.makeAsync(UserBuilder, [user, this.config]);
-    }
-    /**
-     * Define custom connection
-     */
-    setConnection(connection) {
-        this.connection = connection;
-        return this;
-    }
-    /**
-     * Define before hooks. Check interface for exact type information
-     */
-    before(event, callback) {
-        this.hooks.add('before', event, callback);
-        return this;
-    }
-    /**
-     * Define after hooks. Check interface for exact type information
-     */
-    after(event, callback) {
-        this.hooks.add('after', event, callback);
-        return this;
-    }
-    /**
-     * Returns a user instance using the primary key value
-     */
-    async findById(id) {
-        const { query } = await this.getModelQuery();
-        return this.findUser(query.where(this.config.identifierKey, id));
-    }
-    /**
-     * Returns a user instance using a specific token type and value
-     */
-    async findByRememberMeToken(id, value) {
-        const { query } = await this.getModelQuery();
-        return this.findUser(query.where(this.config.identifierKey, id).where('rememberMeToken', value));
-    }
-    /**
-     * Returns the user instance by searching the uidValue against
-     * their defined uids.
-     */
-    async findByUid(uidValue) {
-        const model = await this.getModel();
-        /**
-         * Use custom function on the model. This time, we do not emit
-         * an event, since the user custom lookup may not even
-         * run a query at all.
-         */
-        if (typeof model.findForAuth === 'function') {
-            const user = await model.findForAuth(this.config.uids, uidValue);
-            return this.getUserFor(user);
-        }
-        /**
-         * Lookup by running a custom query.
-         */
-        const { query } = await this.getModelQuery();
-        this.config.uids.forEach((uid) => query.orWhere(uid, uidValue));
-        return this.findUser(query);
-    }
-    /**
-     * Updates the user remember me token. The guard must called `setRememberMeToken`
-     * before invoking this method.
-     */
-    async updateRememberMeToken(providerUser) {
-        /**
-         * Extra check to find malformed guards
-         */
-        if (!providerUser.user.$dirty.rememberMeToken) {
-            throw new Error('The guard must called "setRememberMeToken" before calling "updateRememberMeToken" on the Lucid provider');
-        }
-        await providerUser.user.save();
-    }
-}
-exports.LucidProvider = LucidProvider;

package/build/standalone.d.ts

@@ -1 +0,0 @@
-export { AuthenticationException } from './src/Exceptions/AuthenticationException';

package/build/standalone.js

@@ -1,13 +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.AuthenticationException = void 0;
-var AuthenticationException_1 = require("./src/Exceptions/AuthenticationException");
-Object.defineProperty(exports, "AuthenticationException", { enumerable: true, get: function () { return AuthenticationException_1.AuthenticationException; } });

package/build/templates/config/auth.txt

@@ -1,34 +0,0 @@
-/**
- * Config source: https://git.io/JY0mp
- *
- * Feel free to let us know via PR, if you find something broken in this config
- * file.
- */
-
-import type { AuthConfig } from '@ioc:Adonis/Addons/Auth'
-
-/*
-|--------------------------------------------------------------------------
-| Authentication Mapping
-|--------------------------------------------------------------------------
-|
-| List of available authentication mapping. You must first define them
-| inside the `contracts/auth.ts` file before mentioning them here.
-|
-*/
-const authConfig: AuthConfig = {
-  guard: '{{ guards.0 }}',
-  guards: {
-{{#hasGuard.web}}
-{{> web_guard}}
-{{/hasGuard.web}}
-{{#hasGuard.api}}
-{{> api_guard}}
-{{/hasGuard.api}}
-{{#hasGuard.basic}}
-{{> basic_guard}}
-{{/hasGuard.basic}}
-  },
-}
-
-export default authConfig

package/build/templates/config/partials/api-guard.txt

@@ -1,22 +0,0 @@
-    /*
-    |--------------------------------------------------------------------------
-    | OAT Guard
-    |--------------------------------------------------------------------------
-    |
-    | OAT (Opaque access tokens) guard uses database backed tokens to authenticate
-    | HTTP request. This guard DOES NOT rely on sessions or cookies and uses
-    | Authorization header value for authentication.
-    |
-    | Use this guard to authenticate mobile apps or web clients that cannot rely
-    | on cookies/sessions.
-    |
-    */
-    api: {
-      driver: 'oat',
-
-      {{> token_provider}}
-
-      provider: {
-  {{> provider}}
-      },
-    },

package/build/templates/config/partials/basic-guard.txt

@@ -1,19 +0,0 @@
-    /*
-    |--------------------------------------------------------------------------
-    | Basic Auth Guard
-    |--------------------------------------------------------------------------
-    |
-    | Uses Basic auth to authenticate an HTTP request. There is no concept of
-    | "login" and "logout" with basic auth. You just authenticate the requests
-    | using a middleware and browser will prompt the user to enter their login
-    | details
-    |
-    */
-    basic: {
-      driver: 'basic',
-      realm: 'Login',
-
-      provider: {
-  {{> provider}}
-      },
-    },

package/build/templates/config/partials/tokens-provider-database.txt

@@ -1,19 +0,0 @@
-/*
-|--------------------------------------------------------------------------
-| Tokens provider
-|--------------------------------------------------------------------------
-|
-| Uses SQL database for managing tokens. Use the "database" driver, when
-| tokens are the secondary mode of authentication.
-| For example: The Github personal tokens
-|
-| The foreignKey column is used to make the relationship between the user
-| and the token. You are free to use any column name here.
-|
-*/
-tokenProvider: {
-  type: 'api',
-  driver: 'database',
-  table: 'api_tokens',
-  foreignKey: 'user_id',
-},

package/build/templates/config/partials/tokens-provider-redis.txt

@@ -1,22 +0,0 @@
-/*
-|--------------------------------------------------------------------------
-| Redis provider for managing tokens
-|--------------------------------------------------------------------------
-|
-| Uses Redis for managing tokens. We recommend using the "redis" driver
-| over the "database" driver when the tokens based auth is the
-| primary authentication mode.
-|
-| Redis ensure that all the expired tokens gets cleaned up automatically.
-| Whereas with SQL, you have to cleanup expired tokens manually.
-|
-| The foreignKey column is used to make the relationship between the user
-| and the token. You are free to use any column name here.
-|
-*/
-tokenProvider: {
-  type: 'api',
-  driver: 'redis',
-  redisConnection: 'local',
-  foreignKey: 'user_id',
-},

package/build/templates/config/partials/user-provider-database.txt

@@ -1,43 +0,0 @@
-      /*
-      |--------------------------------------------------------------------------
-      | Driver
-      |--------------------------------------------------------------------------
-      |
-      | Name of the driver
-      |
-      */
-      driver: 'database',
-
-      /*
-      |--------------------------------------------------------------------------
-      | Identifier key
-      |--------------------------------------------------------------------------
-      |
-      | The identifier key is the unique key inside the defined database table.
-      | In most cases specifying the primary key is the right choice.
-      |
-      */
-      identifierKey: 'id',
-
-      /*
-      |--------------------------------------------------------------------------
-      | Uids
-      |--------------------------------------------------------------------------
-      |
-      | Uids are used to search a user against one of the mentioned columns. During
-      | login, the auth module will search the user mentioned value against one
-      | of the mentioned columns to find their user record.
-      |
-      */
-      uids: ['email'],
-
-      /*
-      |--------------------------------------------------------------------------
-      | Database table
-      |--------------------------------------------------------------------------
-      |
-      | The database table to query. Make sure the database table has a `password`
-      | field and `remember_me_token` column.
-      |
-      */
-      usersTable: '{{ usersTableName }}',

package/build/templates/config/partials/user-provider-lucid.txt

@@ -1,45 +0,0 @@
-      /*
-      |--------------------------------------------------------------------------
-      | Driver
-      |--------------------------------------------------------------------------
-      |
-      | Name of the driver
-      |
-      */
-      driver: 'lucid',
-
-      /*
-      |--------------------------------------------------------------------------
-      | Identifier key
-      |--------------------------------------------------------------------------
-      |
-      | The identifier key is the unique key on the model. In most cases specifying
-      | the primary key is the right choice.
-      |
-      */
-      identifierKey: 'id',
-
-      /*
-      |--------------------------------------------------------------------------
-      | Uids
-      |--------------------------------------------------------------------------
-      |
-      | Uids are used to search a user against one of the mentioned columns. During
-      | login, the auth module will search the user mentioned value against one
-      | of the mentioned columns to find their user record.
-      |
-      */
-      uids: ['email'],
-
-      /*
-      |--------------------------------------------------------------------------
-      | Model
-      |--------------------------------------------------------------------------
-      |
-      | The model to use for fetching or finding users. The model is imported
-      | lazily since the config files are read way earlier in the lifecycle
-      | of booting the app and the models may not be in a usable state at
-      | that time.
-      |
-      */
-      model: () => import('{{{ modelNamespace }}}'),

package/build/templates/config/partials/web-guard.txt

@@ -1,17 +0,0 @@
-    /*
-    |--------------------------------------------------------------------------
-    | Web Guard
-    |--------------------------------------------------------------------------
-    |
-    | Web guard uses classic old school sessions for authenticating users.
-    | If you are building a standard web application, it is recommended to
-    | use web guard with session driver
-    |
-    */
-    web: {
-      driver: 'session',
-
-      provider: {
-  {{> provider}}
-      },
-    },

package/build/templates/contract/auth.txt

@@ -1,55 +0,0 @@
-/**
- * Contract source: https://git.io/JOdz5
- *
- * Feel free to let us know via PR, if you find something broken in this
- * file.
- */
-{{#modelNamespace}}
-
-import {{ modelName }} from '{{{ modelNamespace }}}'
-{{/modelNamespace}}
-
-declare module '@ioc:Adonis/Addons/Auth' {
-  /*
-  |--------------------------------------------------------------------------
-  | Providers
-  |--------------------------------------------------------------------------
-  |
-  | The providers are used to fetch users. The Auth module comes pre-bundled
-  | with two providers that are `Lucid` and `Database`. Both uses database
-  | to fetch user details.
-  |
-  | You can also create and register your own custom providers.
-  |
-  */
-  interface ProvidersList {
-{{> provider}}
-  }
-
-  /*
-  |--------------------------------------------------------------------------
-  | Guards
-  |--------------------------------------------------------------------------
-  |
-  | The guards are used for authenticating users using different drivers.
-  | The auth module comes with 3 different guards.
-  |
-  | - SessionGuardContract
-  | - BasicAuthGuardContract
-  | - OATGuardContract ( Opaque access token )
-  |
-  | Every guard needs a provider for looking up users from the database.
-  |
-  */
-  interface GuardsList {
-{{#hasGuard.web}}
-{{> web_guard}}
-{{/hasGuard.web}}
-{{#hasGuard.api}}
-{{> api_guard}}
-{{/hasGuard.api}}
-{{#hasGuard.basic}}
-{{> basic_guard}}
-{{/hasGuard.basic}}
-  }
-}

package/build/templates/contract/partials/api-guard.txt

@@ -1,14 +0,0 @@
-    /*
-    |--------------------------------------------------------------------------
-    | OAT Guard
-    |--------------------------------------------------------------------------
-    |
-    | OAT, stands for (Opaque access tokens) guard uses database backed tokens
-    | to authenticate requests.
-    |
-    */
-    api: {
-      implementation: OATGuardContract<'user', 'api'>
-      config: OATGuardConfig<'user'>
-      client: OATClientContract<'user'>
-    }

package/build/templates/contract/partials/basic-guard.txt

@@ -1,14 +0,0 @@
-    /*
-    |--------------------------------------------------------------------------
-    | Basic Auth Guard
-    |--------------------------------------------------------------------------
-    |
-    | The basic guard uses basic auth for maintaining user login state. It uses
-    | the `user` provider for fetching user details.
-    |
-    */
-    basic: {
-      implementation: BasicAuthGuardContract<'user', 'basic'>
-      config: BasicAuthGuardConfig<'user'>
-      client: BasicAuthClientContract<'user'>
-    }

package/build/templates/contract/partials/user-provider-database.txt

@@ -1,16 +0,0 @@
-    /*
-    |--------------------------------------------------------------------------
-    | User Provider
-    |--------------------------------------------------------------------------
-    |
-    | The following provider directlly uses Database query builder for fetching
-    | user details from the database for authentication.
-    |
-    | You can create multiple providers using the same underlying driver with
-    | different database tables.
-    |
-    */
-    user: {
-      implementation: DatabaseProviderContract<DatabaseProviderRow>
-      config: DatabaseProviderConfig
-    }

package/build/templates/contract/partials/user-provider-lucid.txt

@@ -1,16 +0,0 @@
-    /*
-    |--------------------------------------------------------------------------
-    | User Provider
-    |--------------------------------------------------------------------------
-    |
-    | The following provider uses Lucid models as a driver for fetching user
-    | details from the database for authentication.
-    |
-    | You can create multiple providers using the same underlying driver with
-    | different Lucid models.
-    |
-    */
-    user: {
-      implementation: LucidProviderContract<typeof {{ modelName }}>
-      config: LucidProviderConfig<typeof {{ modelName }}>
-    }

package/build/templates/contract/partials/web-guard.txt

@@ -1,14 +0,0 @@
-    /*
-    |--------------------------------------------------------------------------
-    | Web Guard
-    |--------------------------------------------------------------------------
-    |
-    | The web guard uses sessions for maintaining user login state. It uses
-    | the `user` provider for fetching user details.
-    |
-    */
-    web: {
-      implementation: SessionGuardContract<'user', 'web'>
-      config: SessionGuardConfig<'user'>
-      client: SessionClientContract<'user'>
-    }

package/build/templates/middleware/Auth.txt

@@ -1,76 +0,0 @@
-import { AuthenticationException } from '@adonisjs/auth/build/standalone'
-import type { GuardsList } from '@ioc:Adonis/Addons/Auth'
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
-
-/**
- * Auth middleware is meant to restrict un-authenticated access to a given route
- * or a group of routes.
- *
- * You must register this middleware inside `start/kernel.ts` file under the list
- * of named middleware.
- */
-export default class AuthMiddleware {
-  /**
-   * The URL to redirect to when request is Unauthorized
-   */
-  protected redirectTo = '/login'
-
-  /**
-   * Authenticates the current HTTP request against a custom set of defined
-   * guards.
-   *
-   * The authentication loop stops as soon as the user is authenticated using any
-   * of the mentioned guards and that guard will be used by the rest of the code
-   * during the current request.
-   */
-  protected async authenticate(auth: HttpContextContract['auth'], guards: (keyof GuardsList)[]) {
-    /**
-     * Hold reference to the guard last attempted within the for loop. We pass
-     * the reference of the guard to the "AuthenticationException", so that
-     * it can decide the correct response behavior based upon the guard
-     * driver
-     */
-    let guardLastAttempted: string | undefined
-
-    for (let guard of guards) {
-      guardLastAttempted = guard
-
-      if (await auth.use(guard).check()) {
-        /**
-         * Instruct auth to use the given guard as the default guard for
-         * the rest of the request, since the user authenticated
-         * succeeded here
-         */
-        auth.defaultGuard = guard
-        return true
-      }
-    }
-
-    /**
-     * Unable to authenticate using any guard
-     */
-    throw new AuthenticationException(
-      'Unauthorized access',
-      'E_UNAUTHORIZED_ACCESS',
-      guardLastAttempted,
-      this.redirectTo,
-    )
-  }
-
-  /**
-   * Handle request
-   */
-  public async handle (
-    { auth }: HttpContextContract,
-    next: () => Promise<void>,
-    customGuards: (keyof GuardsList)[]
-  ) {
-    /**
-     * Uses the user defined guards or the default guard mentioned in
-     * the config file
-     */
-    const guards = customGuards.length ? customGuards : [auth.name]
-    await this.authenticate(auth, guards)
-    await next()
-  }
-}

package/build/templates/middleware/SilentAuth.txt

@@ -1,21 +0,0 @@
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
-
-/**
- * Silent auth middleware can be used as a global middleware to silent check
- * if the user is logged-in or not.
- *
- * The request continues as usual, even when the user is not logged-in.
- */
-export default class SilentAuthMiddleware {
-  /**
-   * Handle request
-   */
-  public async handle({ auth }: HttpContextContract, next: () => Promise<void>) {
-    /**
-     * Check if user is logged-in or not. If yes, then `ctx.auth.user` will be
-     * set to the instance of the currently logged in user.
-     */
-    await auth.check()
-    await next()
-  }
-}

package/build/templates/migrations/api_tokens.txt

@@ -1,25 +0,0 @@
-import BaseSchema from '@ioc:Adonis/Lucid/Schema'
-
-export default class extends BaseSchema {
-  protected tableName = '{{ tokensTableName }}'
-
-  public async up() {
-    this.schema.createTable(this.tableName, (table) => {
-      table.increments('id').primary()
-      table.integer('user_id').unsigned().references('id').inTable('{{ usersTableName }}').onDelete('CASCADE')
-      table.string('name').notNullable()
-      table.string('type').notNullable()
-      table.string('token', 64).notNullable().unique()
-
-      /**
-       * Uses timestampz for PostgreSQL and DATETIME2 for MSSQL
-       */
-      table.timestamp('expires_at', { useTz: true }).nullable()
-      table.timestamp('created_at', { useTz: true }).notNullable()
-    })
-  }
-
-  public async down() {
-    this.schema.dropTable(this.tableName)
-  }
-}

package/build/templates/migrations/auth.txt

@@ -1,24 +0,0 @@
-import BaseSchema from '@ioc:Adonis/Lucid/Schema'
-
-export default class extends BaseSchema {
-  protected tableName = '{{ usersTableName }}'
-
-  public async up() {
-    this.schema.createTable(this.tableName, (table) => {
-      table.increments('id').primary()
-      table.string('email', 255).notNullable().unique()
-      table.string('password', 180).notNullable()
-      table.string('remember_me_token').nullable()
-
-      /**
-       * Uses timestampz for PostgreSQL and DATETIME2 for MSSQL
-       */
-      table.timestamp('created_at', { useTz: true }).notNullable()
-      table.timestamp('updated_at', { useTz: true }).notNullable()
-    })
-  }
-
-  public async down() {
-    this.schema.dropTable(this.tableName)
-  }
-}