@adonisjs/auth 8.2.3 → 9.0.0-0

package/build/src/Guards/Session/index.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 });
-exports.SessionGuard = void 0;
-const utils_1 = require("@poppinss/utils");
-const helpers_1 = require("@poppinss/utils/build/helpers");
-const Base_1 = require("../Base");
-const AuthenticationException_1 = require("../../Exceptions/AuthenticationException");
-/**
- * Session guard enables user login using sessions. Also it allows for
- * setting remember me tokens for life long login
- */
-class SessionGuard extends Base_1.BaseGuard {
-    constructor(name, config, emitter, provider, ctx) {
-        super(name, config, provider);
-        this.emitter = emitter;
-        this.ctx = ctx;
-        /**
-         * Number of years for the remember me token expiry
-         */
-        this.rememberMeTokenExpiry = '5y';
-    }
-    /**
-     * The name of the session key name
-     */
-    get sessionKeyName() {
-        return `auth_${this.name}`;
-    }
-    /**
-     * The name of the session key name
-     */
-    get rememberMeKeyName() {
-        return `remember_${this.name}`;
-    }
-    /**
-     * Returns the session object from the context.
-     */
-    getSession() {
-        if (!this.ctx.session) {
-            throw new utils_1.Exception('"@adonisjs/session" is required to use the "session" auth driver');
-        }
-        return this.ctx.session;
-    }
-    /**
-     * Set the user id inside the session. Also forces the session module
-     * to re-generate the session id
-     */
-    setSession(userId) {
-        this.getSession().put(this.sessionKeyName, userId);
-        this.getSession().regenerate();
-    }
-    /**
-     * Generate remember me token
-     */
-    generateRememberMeToken() {
-        return helpers_1.string.generateRandom(20);
-    }
-    /**
-     * Sets the remember me cookie with the remember me token
-     */
-    setRememberMeCookie(userId, token) {
-        const value = {
-            id: userId,
-            token: token,
-        };
-        this.ctx.response.encryptedCookie(this.rememberMeKeyName, value, {
-            maxAge: this.rememberMeTokenExpiry,
-            httpOnly: true,
-        });
-    }
-    /**
-     * Clears the remember me cookie
-     */
-    clearRememberMeCookie() {
-        this.ctx.response.clearCookie(this.rememberMeKeyName);
-    }
-    /**
-     * Clears user session and remember me cookie
-     */
-    clearUserFromStorage() {
-        this.getSession().forget(this.sessionKeyName);
-        this.clearRememberMeCookie();
-    }
-    /**
-     * Returns data packet for the login event. Arguments are
-     *
-     * - The mapping identifier
-     * - Logged in user
-     * - HTTP context
-     * - Remember me token (optional)
-     */
-    getLoginEventData(user, token) {
-        return {
-            name: this.name,
-            ctx: this.ctx,
-            user,
-            token,
-        };
-    }
-    /**
-     * Returns data packet for the authenticate event. Arguments are
-     *
-     * - The mapping identifier
-     * - Logged in user
-     * - HTTP context
-     * - A boolean to tell if logged in viaRemember or not
-     */
-    getAuthenticateEventData(user, viaRemember) {
-        return {
-            name: this.name,
-            ctx: this.ctx,
-            user,
-            viaRemember,
-        };
-    }
-    /**
-     * Returns the user id for the current HTTP request
-     */
-    getRequestSessionId() {
-        return this.getSession().get(this.sessionKeyName);
-    }
-    /**
-     * Verifies the remember me token
-     */
-    verifyRememberMeToken(rememberMeToken) {
-        if (!rememberMeToken || !rememberMeToken.id || !rememberMeToken.token) {
-            throw AuthenticationException_1.AuthenticationException.invalidSession(this.name);
-        }
-    }
-    /**
-     * Returns user from the user session id
-     */
-    async getUserForSessionId(id) {
-        const authenticatable = await this.provider.findById(id);
-        if (!authenticatable.user) {
-            throw AuthenticationException_1.AuthenticationException.invalidSession(this.name);
-        }
-        return authenticatable;
-    }
-    /**
-     * Returns user for the remember me token
-     */
-    async getUserForRememberMeToken(id, token) {
-        const authenticatable = await this.provider.findByRememberMeToken(id, token);
-        if (!authenticatable.user) {
-            throw AuthenticationException_1.AuthenticationException.invalidSession(this.name);
-        }
-        return authenticatable;
-    }
-    /**
-     * Returns the remember me token of the user that is persisted
-     * inside the db. If not persisted, we create one and persist
-     * it
-     */
-    async getPersistedRememberMeToken(providerUser) {
-        /**
-         * Create and persist the user remember me token, when an existing one is missing
-         */
-        if (!providerUser.getRememberMeToken()) {
-            this.ctx.logger.trace('generating fresh remember me token');
-            providerUser.setRememberMeToken(this.generateRememberMeToken());
-            await this.provider.updateRememberMeToken(providerUser);
-        }
-        return providerUser.getRememberMeToken();
-    }
-    /**
-     * Verify user credentials and perform login
-     */
-    async attempt(uid, password, remember) {
-        const user = await this.verifyCredentials(uid, password);
-        await this.login(user, remember);
-        return user;
-    }
-    /**
-     * Login user using their id
-     */
-    async loginViaId(id, remember) {
-        const providerUser = await this.findById(id);
-        await this.login(providerUser.user, remember);
-        return providerUser.user;
-    }
-    /**
-     * Login a user
-     */
-    async login(user, remember) {
-        /**
-         * Since the login method is exposed to the end user, we cannot expect
-         * them to instantiate and return an instance of authenticatable, so
-         * we create one manually.
-         */
-        const providerUser = await this.getUserForLogin(user, this.config.provider.identifierKey);
-        /**
-         * getUserForLogin raises exception when id is missing, so we can
-         * safely assume it is defined
-         */
-        const id = providerUser.getId();
-        /**
-         * Set session
-         */
-        this.setSession(id);
-        /**
-         * Set remember me token when enabled
-         */
-        if (remember) {
-            const rememberMeToken = await this.getPersistedRememberMeToken(providerUser);
-            this.ctx.logger.trace('setting remember me cookie', { name: this.rememberMeKeyName });
-            this.setRememberMeCookie(id, rememberMeToken);
-        }
-        else {
-            /**
-             * Clear remember me cookie, which may have been set previously.
-             */
-            this.clearRememberMeCookie();
-        }
-        /**
-         * Emit login event. It can be used to track user logins and their devices.
-         */
-        this.emitter.emit('adonis:session:login', this.getLoginEventData(providerUser.user, providerUser.getRememberMeToken()));
-        this.markUserAsLoggedIn(providerUser.user);
-        return providerUser.user;
-    }
-    /**
-     * Authenticates the current HTTP request by checking for the user
-     * session.
-     */
-    async authenticate() {
-        if (this.authenticationAttempted) {
-            return this.user;
-        }
-        this.authenticationAttempted = true;
-        const sessionId = this.getRequestSessionId();
-        /**
-         * If session id exists, then attempt to login the user using the
-         * session and return early
-         */
-        if (sessionId) {
-            const providerUser = await this.getUserForSessionId(sessionId);
-            this.markUserAsLoggedIn(providerUser.user, true);
-            this.emitter.emit('adonis:session:authenticate', this.getAuthenticateEventData(providerUser.user, false));
-            return this.user;
-        }
-        /**
-         * Otherwise look for remember me token. Raise exception, if both remember
-         * me token and session id are missing.
-         */
-        const rememberMeToken = this.ctx.request.encryptedCookie(this.rememberMeKeyName);
-        if (!rememberMeToken) {
-            throw AuthenticationException_1.AuthenticationException.invalidSession(this.name);
-        }
-        /**
-         * Ensure remember me token is valid after reading it from the cookie
-         */
-        this.verifyRememberMeToken(rememberMeToken);
-        /**
-         * Attempt to locate the user for remember me token
-         */
-        const providerUser = await this.getUserForRememberMeToken(rememberMeToken.id, rememberMeToken.token);
-        this.setSession(providerUser.getId());
-        this.setRememberMeCookie(rememberMeToken.id, rememberMeToken.token);
-        this.markUserAsLoggedIn(providerUser.user, true, true);
-        this.emitter.emit('adonis:session:authenticate', this.getAuthenticateEventData(providerUser.user, true));
-        return this.user;
-    }
-    /**
-     * Same as [[authenticate]] but returns a boolean over raising exceptions
-     */
-    async check() {
-        try {
-            await this.authenticate();
-        }
-        catch (error) {
-            /**
-             * Throw error when it is not an instance of the authentication
-             */
-            if (error instanceof AuthenticationException_1.AuthenticationException === false) {
-                throw error;
-            }
-            this.ctx.logger.trace(error, 'Authentication failure');
-        }
-        return this.isAuthenticated;
-    }
-    /**
-     * Logout by clearing session and cookies
-     */
-    async logout(recycleRememberToken) {
-        /**
-         * Return early when not attempting to re-generate the remember me token
-         */
-        if (!recycleRememberToken) {
-            this.clearUserFromStorage();
-            this.markUserAsLoggedOut();
-            return;
-        }
-        /**
-         * Attempt to authenticate the current request if not already authenticated. This
-         * will help us get an instance of the current user
-         */
-        if (!this.authenticationAttempted) {
-            await this.check();
-        }
-        /**
-         * If authentication passed, then re-generate the remember me token
-         * for the current user.
-         */
-        if (this.user) {
-            const providerUser = await this.provider.getUserFor(this.user);
-            this.ctx.logger.trace('re-generating remember me token');
-            providerUser.setRememberMeToken(this.generateRememberMeToken());
-            await this.provider.updateRememberMeToken(providerUser);
-        }
-        /**
-         * Logout user
-         */
-        this.clearUserFromStorage();
-        this.markUserAsLoggedOut();
-    }
-    /**
-     * Serialize toJSON for JSON.stringify
-     */
-    toJSON() {
-        return {
-            isLoggedIn: this.isLoggedIn,
-            isGuest: this.isGuest,
-            viaRemember: this.viaRemember,
-            authenticationAttempted: this.authenticationAttempted,
-            isAuthenticated: this.isAuthenticated,
-            user: this.user,
-        };
-    }
-}
-exports.SessionGuard = SessionGuard;

package/build/src/TokenProviders/Database/index.d.ts

@@ -1,43 +0,0 @@
-import { DatabaseContract, QueryClientContract } from '@ioc:Adonis/Lucid/Database';
-import { TokenProviderContract, ProviderTokenContract, DatabaseTokenProviderConfig } from '@ioc:Adonis/Addons/Auth';
-import { ProviderToken } from '../../Tokens/ProviderToken';
-/**
- * Database backend tokens provider
- */
-export declare class TokenDatabaseProvider implements TokenProviderContract {
-    private config;
-    private db;
-    constructor(config: DatabaseTokenProviderConfig, db: DatabaseContract);
-    /**
-     * Custom connection or query client
-     */
-    private connection?;
-    /**
-     * Returns the query client for database queries
-     */
-    private getQueryClient;
-    /**
-     * The foreign key column
-     */
-    private foreignKey;
-    /**
-     * Returns the builder query for a given token + type
-     */
-    private getLookupQuery;
-    /**
-     * Define custom connection
-     */
-    setConnection(connection: string | QueryClientContract): this;
-    /**
-     * Reads the token using the lookup token id
-     */
-    read(tokenId: string, tokenHash: string, tokenType: string): Promise<ProviderTokenContract | null>;
-    /**
-     * Saves the token and returns the persisted token lookup id.
-     */
-    write(token: ProviderToken): Promise<string>;
-    /**
-     * Removes a given token
-     */
-    destroy(tokenId: string, tokenType: string): Promise<void>;
-}

package/build/src/TokenProviders/Database/index.js

@@ -1,126 +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.TokenDatabaseProvider = void 0;
-const luxon_1 = require("luxon");
-const helpers_1 = require("@poppinss/utils/build/helpers");
-const ProviderToken_1 = require("../../Tokens/ProviderToken");
-/**
- * Database backend tokens provider
- */
-class TokenDatabaseProvider {
-    constructor(config, db) {
-        this.config = config;
-        this.db = db;
-        /**
-         * The foreign key column
-         */
-        this.foreignKey = this.config.foreignKey || 'user_id';
-    }
-    /**
-     * Returns the query client for database queries
-     */
-    getQueryClient() {
-        if (!this.connection) {
-            return this.db.connection(this.config.connection);
-        }
-        return typeof this.connection === 'string'
-            ? this.db.connection(this.connection)
-            : this.connection;
-    }
-    /**
-     * Returns the builder query for a given token + type
-     */
-    getLookupQuery(tokenId, tokenType) {
-        return this.getQueryClient()
-            .from(this.config.table)
-            .where('id', tokenId)
-            .where('type', tokenType);
-    }
-    /**
-     * Define custom connection
-     */
-    setConnection(connection) {
-        this.connection = connection;
-        return this;
-    }
-    /**
-     * Reads the token using the lookup token id
-     */
-    async read(tokenId, tokenHash, tokenType) {
-        const client = this.getQueryClient();
-        /**
-         * Find token using id
-         */
-        const tokenRow = await this.getLookupQuery(tokenId, tokenType).first();
-        if (!tokenRow || !tokenRow.token) {
-            return null;
-        }
-        /**
-         * Ensure hash of the user provided value is same as the one inside
-         * the database
-         */
-        if (!(0, helpers_1.safeEqual)(tokenRow.token, tokenHash)) {
-            return null;
-        }
-        const { name, [this.foreignKey]: userId, token: value, expires_at: expiresAt, type, ...meta } = tokenRow;
-        let normalizedExpiryDate;
-        /**
-         * Parse dialect date to an instance of Luxon
-         */
-        if (expiresAt instanceof Date) {
-            normalizedExpiryDate = luxon_1.DateTime.fromJSDate(expiresAt);
-        }
-        else if (expiresAt && typeof expiresAt === 'string') {
-            normalizedExpiryDate = luxon_1.DateTime.fromFormat(expiresAt, client.dialect.dateTimeFormat);
-        }
-        else if (expiresAt && typeof expiresAt === 'number') {
-            normalizedExpiryDate = luxon_1.DateTime.fromMillis(expiresAt);
-        }
-        /**
-         * Ensure token isn't expired
-         */
-        if (normalizedExpiryDate &&
-            normalizedExpiryDate.diff(luxon_1.DateTime.local(), 'milliseconds').milliseconds <= 0) {
-            return null;
-        }
-        const token = new ProviderToken_1.ProviderToken(name, value, userId, type);
-        token.expiresAt = expiresAt;
-        token.meta = meta;
-        return token;
-    }
-    /**
-     * Saves the token and returns the persisted token lookup id.
-     */
-    async write(token) {
-        const client = this.getQueryClient();
-        /**
-         * Payload to save to the database
-         */
-        const payload = {
-            [this.foreignKey]: token.userId,
-            name: token.name,
-            token: token.tokenHash,
-            type: token.type,
-            expires_at: token.expiresAt ? token.expiresAt.toFormat(client.dialect.dateTimeFormat) : null,
-            created_at: luxon_1.DateTime.local().toFormat(client.dialect.dateTimeFormat),
-            ...token.meta,
-        };
-        const [row] = await client.table(this.config.table).insert(payload).returning('id');
-        return String(typeof row === 'number' ? row : row.id);
-    }
-    /**
-     * Removes a given token
-     */
-    async destroy(tokenId, tokenType) {
-        await this.getLookupQuery(tokenId, tokenType).delete();
-    }
-}
-exports.TokenDatabaseProvider = TokenDatabaseProvider;

package/build/src/TokenProviders/Redis/index.d.ts

@@ -1,44 +0,0 @@
-import { RedisManagerContract, RedisConnectionContract, RedisClusterConnectionContract } from '@ioc:Adonis/Addons/Redis';
-import { TokenProviderContract, ProviderTokenContract, RedisTokenProviderConfig } from '@ioc:Adonis/Addons/Auth';
-import { ProviderToken } from '../../Tokens/ProviderToken';
-/**
- * Redis backed tokens provider.
- */
-export declare class TokenRedisProvider implements TokenProviderContract {
-    private config;
-    private redis;
-    constructor(config: RedisTokenProviderConfig, redis: RedisManagerContract);
-    /**
-     * Custom connection or query client
-     */
-    private connection?;
-    /**
-     * Returns the singleton instance of the redis connection
-     */
-    private getRedisConnection;
-    /**
-     * The foreign key column
-     */
-    private foreignKey;
-    /**
-     * Parse the stringified redis token value to an object
-     */
-    private parseToken;
-    /**
-     * Define custom connection
-     */
-    setConnection(connection: string | RedisConnectionContract | RedisClusterConnectionContract): this;
-    /**
-     * Reads the token using the lookup token id
-     */
-    read(tokenId: string, tokenHash: string, tokenType: string): Promise<ProviderTokenContract | null>;
-    /**
-     * Saves the token and returns the persisted token lookup id, which
-     * is a cuid.
-     */
-    write(token: ProviderToken): Promise<string>;
-    /**
-     * Removes a given token
-     */
-    destroy(tokenId: string, tokenType: string): Promise<void>;
-}

package/build/src/TokenProviders/Redis/index.js

@@ -1,129 +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.TokenRedisProvider = void 0;
-const utils_1 = require("@poppinss/utils");
-const helpers_1 = require("@poppinss/utils/build/helpers");
-const ProviderToken_1 = require("../../Tokens/ProviderToken");
-/**
- * Redis backed tokens provider.
- */
-class TokenRedisProvider {
-    constructor(config, redis) {
-        this.config = config;
-        this.redis = redis;
-        /**
-         * The foreign key column
-         */
-        this.foreignKey = this.config.foreignKey || 'user_id';
-    }
-    /**
-     * Returns the singleton instance of the redis connection
-     */
-    getRedisConnection() {
-        /**
-         * Use custom connection if defined
-         */
-        if (this.connection) {
-            return typeof this.connection === 'string'
-                ? this.redis.connection(this.connection)
-                : this.connection;
-        }
-        /**
-         * Config must have a connection defined
-         */
-        if (!this.config.redisConnection) {
-            throw new utils_1.Exception('Missing "redisConnection" property for auth redis provider inside "config/auth" file', 500, 'E_INVALID_AUTH_REDIS_CONFIG');
-        }
-        return this.redis.connection(this.config.redisConnection);
-    }
-    /**
-     * Parse the stringified redis token value to an object
-     */
-    parseToken(token) {
-        if (!token) {
-            return null;
-        }
-        try {
-            const tokenRow = JSON.parse(token);
-            if (!tokenRow.token || !tokenRow.name || !tokenRow[this.foreignKey]) {
-                return null;
-            }
-            return tokenRow;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Define custom connection
-     */
-    setConnection(connection) {
-        this.connection = connection;
-        return this;
-    }
-    /**
-     * Reads the token using the lookup token id
-     */
-    async read(tokenId, tokenHash, tokenType) {
-        /**
-         * Find token using id
-         */
-        const tokenRow = this.parseToken(await this.getRedisConnection().get(`${tokenType}:${tokenId}`));
-        if (!tokenRow) {
-            return null;
-        }
-        /**
-         * Ensure hash of the user provided value is same as the one inside
-         * the database
-         */
-        if (!(0, helpers_1.safeEqual)(tokenRow.token, tokenHash)) {
-            return null;
-        }
-        const { name, [this.foreignKey]: userId, token: value, ...meta } = tokenRow;
-        const token = new ProviderToken_1.ProviderToken(name, value, userId, tokenType);
-        token.meta = meta;
-        return token;
-    }
-    /**
-     * Saves the token and returns the persisted token lookup id, which
-     * is a cuid.
-     */
-    async write(token) {
-        /**
-         * Payload to save to the database
-         */
-        const payload = {
-            [this.foreignKey]: token.userId,
-            name: token.name,
-            token: token.tokenHash,
-            ...token.meta,
-        };
-        const ttl = token.expiresAt ? Math.ceil(token.expiresAt.diffNow('seconds').seconds) : 0;
-        const tokenId = (0, helpers_1.cuid)();
-        if (token.expiresAt && ttl <= 0) {
-            throw new utils_1.Exception('The expiry date/time should be in the future', 500, 'E_INVALID_TOKEN_EXPIRY');
-        }
-        if (token.expiresAt) {
-            await this.getRedisConnection().setex(`${token.type}:${tokenId}`, ttl, JSON.stringify(payload));
-        }
-        else {
-            await this.getRedisConnection().set(`${token.type}:${tokenId}`, JSON.stringify(payload));
-        }
-        return tokenId;
-    }
-    /**
-     * Removes a given token
-     */
-    async destroy(tokenId, tokenType) {
-        await this.getRedisConnection().del(`${tokenType}:${tokenId}`);
-    }
-}
-exports.TokenRedisProvider = TokenRedisProvider;