@adonisjs/auth/build/modules/access_tokens_guard/user_providers/lucid.d.ts

Official authentication provider for Adonis framework

import { type Secret } from '@adonisjs/core/helpers';
import { type AccessToken } from '../access_token.ts';
import { PROVIDER_REAL_USER } from '../../../src/symbols.ts';
import type { LucidTokenable, AccessTokensGuardUser, AccessTokensUserProviderContract, AccessTokensLucidUserProviderOptions } from '../types.ts';
/**
 * Uses a lucid model to verify access tokens and find a user during
 * authentication
 *
 * @template TokenableProperty - The property name that holds the tokens provider
 * @template UserModel - The Lucid model representing the user
 *
 * @example
 * const userProvider = new AccessTokensLucidUserProvider({
 *   model: () => import('#models/user'),
 *   tokens: 'accessTokens'
 * })
 */
export declare class AccessTokensLucidUserProvider<TokenableProperty extends string, UserModel extends LucidTokenable<TokenableProperty>> implements AccessTokensUserProviderContract<InstanceType<UserModel>> {
    /**
     * Lucid provider options
     */
    protected options: AccessTokensLucidUserProviderOptions<TokenableProperty, UserModel>;
    [PROVIDER_REAL_USER]: InstanceType<UserModel>;
    /**
     * Reference to the lazily imported model
     */
    protected model?: UserModel;
    /**
     * Creates a new AccessTokensLucidUserProvider instance
     *
     * @param options - Configuration options for the user provider
     *
     * @example
     * const provider = new AccessTokensLucidUserProvider({
     *   model: () => import('#models/user'),
     *   tokens: 'accessTokens'
     * })
     */
    constructor(
    /**
     * Lucid provider options
     */
    options: AccessTokensLucidUserProviderOptions<TokenableProperty, UserModel>);
    /**
     * Imports the model from the provider, returns and caches it
     * for further operations.
     *
     * @example
     * const UserModel = await provider.getModel()
     * const user = await UserModel.find(1)
     */
    protected getModel(): Promise<UserModel>;
    /**
     * Returns the tokens provider associated with the user model
     *
     * @example
     * const tokensProvider = await provider.getTokensProvider()
     * const token = await tokensProvider.create(user, ['read'])
     */
    protected getTokensProvider(): Promise<UserModel[TokenableProperty]>;
    /**
     * Creates an adapter user for the guard
     *
     * @param user - The user model instance
     *
     * @example
     * const guardUser = await provider.createUserForGuard(user)
     * console.log('User ID:', guardUser.getId())
     * console.log('Original user:', guardUser.getOriginal())
     */
    createUserForGuard(user: InstanceType<UserModel>): Promise<AccessTokensGuardUser<InstanceType<UserModel>>>;
    /**
     * Create a token for a given user
     *
     * @param user - The user to create a token for
     * @param abilities - Optional array of abilities the token should have
     * @param options - Optional token configuration
     *
     * @example
     * const token = await provider.createToken(user, ['read', 'write'], {
     *   name: 'API Token',
     *   expiresIn: '30d'
     * })
     * console.log('Created token:', token.value.release())
     */
    createToken(user: InstanceType<UserModel>, abilities?: string[] | undefined, options?: {
        name?: string;
        expiresIn?: string | number;
    }): Promise<AccessToken>;
    /**
     * Invalidates a token identified by its publicly shared token
     *
     * @param tokenValue - The token value to invalidate
     *
     * @example
     * const wasInvalidated = await provider.invalidateToken(
     *   new Secret('oat_abc123.def456')
     * )
     * console.log('Token invalidated:', wasInvalidated)
     */
    invalidateToken(tokenValue: Secret<string>): Promise<boolean>;
    /**
     * Finds a user by the user id
     *
     * @param identifier - The user identifier to search for
     *
     * @example
     * const guardUser = await provider.findById(123)
     * if (guardUser) {
     *   const originalUser = guardUser.getOriginal()
     *   console.log('Found user:', originalUser.email)
     * }
     */
    findById(identifier: string | number | BigInt): Promise<AccessTokensGuardUser<InstanceType<UserModel>> | null>;
    /**
     * Verifies a publicly shared access token and returns an
     * access token for it.
     *
     * @param tokenValue - The token value to verify
     *
     * @example
     * const token = await provider.verifyToken(
     *   new Secret('oat_abc123.def456')
     * )
     * if (token && !token.isExpired()) {
     *   console.log('Valid token with abilities:', token.abilities)
     * }
     */
    verifyToken(tokenValue: Secret<string>): Promise<AccessToken | null>;
}