adonis v6 : customUserProvider

[titoff002]

Hello,

I discovered Adonis and I found it (being a Laravel user): I found lots of similarities.

first of all: nice work

My question :

I don't want to use model: () => import('#models/user'), because I don't use a users table to manage my users but an external API: how to do it

I would like to keep all the power of the sessionprovider in order to use it like this :

// start/providers/CustomUserProvider.ts
import { UserProviderContract } from '@ioc:Adonis/Addons/Auth'
import axios from 'axios'

class CustomUserProvider implements UserProviderContract {
  public async findById(id: string) {
    const response = await axios.get(`https://api.xxx.com/users/${id}`)
    return response.data
  }

  public async findByUid(uid: string) {
    const response = await axios.get(`https://api.xxx.com/users?uid=${uid}`)
    return response.data[0]
  }

  public async verifyCredentials(user, password) {
    const response = await axios.post('https://api.xxx.com/auth', {
      uid: user.uid,
      password,
    })
    return response.data.isValid
  }
}

export const customUserProvider = () => {
  return new CustomUserProvider()
}

// start/auth.ts
import { defineConfig } from '@adonisjs/auth/build/config'
import { sessionGuard } from '@adonisjs/auth/build/guards'
import { customUserProvider } from './providers/CustomUserProvider'

export default defineConfig({
  default: 'web',
  guards: {
    web: sessionGuard({
      useRememberMeTokens: false,
      provider: customUserProvider(),
    }),
  },
})

would you have any idea how to do this? Do you have a complete working code?

Thank you in advance for your help and have a nice day.

[titoff002]

additional question: should I still keep/use the User model ?

if yes, the latter will consist of these fields: id_user, nam, firstname, roles (an object or array).

If yes, how to implement/use it in CustomUserProvider.

As a reminder, I do not have and will not use a database table called USER.

[thetutlage]

We have written an article for the same on our blog. https://adonisjs.com/blog/kysely-with-auth-session-guard

The article covers the usage with Kysely (a query builder), but the same principle will apply in your case as well

[titoff002]

@thetutlage

Hello and thank you for your answers. I followed your tutorial and adapted it to my needs. you will find my code below:

// app\providers\IUser.ts

export interface User {
    login: string;
    appToken: string;
    groups: string[];
    infos: {
        dn: string;
        userPrincipalName: string;
        sAMAccountName: string;
        lockoutTime: string;
        whenCreated: string;
        pwdLastSet: string;
        userAccountControl: string;
        givenName: string;
        cn: string;
        displayName: string;
    };
    token: string;
}

//------------ app\providers\CustomUserProvider.ts -----------------

import type { User } from './IUser.js';
import { symbols } from '@adonisjs/auth';
import { SessionGuardUser, SessionUserProviderContract } from '@adonisjs/auth/types/session';
import axios from 'axios';
import https from 'https';

export class SessionKyselyUserProvider implements SessionUserProviderContract<User> {
  declare [symbols.PROVIDER_REAL_USER]: User;

  async createUserForGuard(user: User): Promise<SessionGuardUser<User>> {
    console.log('titoff createUserForGuard');
    return {
      getId() {
        console.log('titoff getId', user.login);
        return user.login; // Assuming login is the unique identifier
      },

      getOriginal() {
        console.log('titoff getOriginal');
        return user;
      },
    };
  }

  async findById(identifier: string): Promise<SessionGuardUser<User> | null> {
    console.log('titoff findById');
    const user: User | null = await this.findUserById(identifier);
    if (!user) {
      return null;
    }

    return this.createUserForGuard(user);
  }

  async findUserById(identifier: string): Promise<User | null> {
    console.log('titoff findUserById', identifier);
    // Implement your logic to find the user by ID
    const user: User | null = await this.findUserById(identifier);
    if (!user) {
      return null;
    }

    return user
  }

  public async verifyCredentials(username: string, password: string): Promise<User | null> {
    try {
      const localCfg = {
        url: process.env.API_URL,
        method: 'post',
        headers: {
          ...axios.defaults.headers,
          'x-usp-token': process.env.API_TOKEN,
        },
        httpsAgent: new https.Agent({
          rejectUnauthorized: false,
        }),

        data: {
          username,
          password,
          appToken: process.env.API_TOKEN,
        },
      };

      const response = await axios(localCfg);
      return response.data;
    } catch (error) {
      console.error('Error verifying credentials:', error);
      return null;
    }
  }
}

//------------- --     config\auth.ts        --------
import { defineConfig } from '@adonisjs/auth'
import { configProvider } from '@adonisjs/core'
import { sessionGuard } from '@adonisjs/auth/session'
import { InferAuthEvents, Authenticators } from '@adonisjs/auth/types'

const authConfig = defineConfig({
  default: 'web',
  guards: {
    web: sessionGuard({
      useRememberMeTokens: false,
      provider: configProvider.create(async () => {
        const { SessionKyselyUserProvider } = await import(
          '../app/providers/CustomUserProvider.js'
        )
        return new SessionKyselyUserProvider()
      }),
    }),
  },
})
export default authConfig

/**
 * Inferring types from the configured auth
 * guards.
 */

declare module '@adonisjs/auth/types' {
  export interface Authenticators extends InferAuthenticators<typeof authConfig> { }
}

declare module '@adonisjs/core/types' {
  interface EventsList extends InferAuthEvents<Authenticators> { }
}

/-----------------  app\controllers\auth_controller.ts -----
import type { HttpContext } from '@adonisjs/core/http'
import { SessionKyselyUserProvider } from '../providers/CustomUserProvider.js'
import { errors } from '@adonisjs/auth'

export default class AuthController {
    private userProvider: SessionKyselyUserProvider
    constructor() {
        this.userProvider = new SessionKyselyUserProvider()
    }

    async login({ auth, request, response, session }: HttpContext) {
        const { username, password } = request.only(['username', 'password'])
        if (!username || !password) {
            throw new errors.E_INVALID_CREDENTIALS('Invalid credentials')
        }

        const user = await this.userProvider.verifyCredentials(username, password)
        if (!user) {
          throw new errors.E_INVALID_CREDENTIALS('Invalid credentials')
        }

        await auth.use('web').login(user)
        const toto = await auth.use('web').getUserOrFail()

        session.put('user', user)
        response.json(user)
    }
}

Question: does my code seem correct to you?

Another question:
when I do CTRL+F5 on my browser: I no longer have anything in my sessions, I have the impression that it loses my user (even though there is a session cookie in my storage of the browser, after that I don't know what's in it): so why on CTRL+F5 is the user no longer in my adonis session?

Thank you for your time and I hope you can give me some answers.

Have a good day.

[titoff002]

It's okay, I found how to do it.

I close this ticket.

thank you.