if i create user from factories, and i use method .exists(), i cannot login, why is that?

[fzhnf]

If I create a user from factories, I cannot login because of the error database.exists() for my email field, but strangely, if I create a user using an HTTP method request, there's no error, thus I can login as expected.

The error must be from my loginValidator, which has the method exists(). I put the method there because my assumption on how it works was that the method should be validating if my email exists or not, or so I thought on how it really works. I can't get the explanation in Lucid nor Vinejs documentation, but I found it from a file database provider in Lucid modules.

declare module '@vinejs/vine' {
    interface VineLucidBindings {
        /**
         * Ensure the value is unique inside the database by self
         * executing a query.
         *
         * - The callback must return "true", if the value is unique (does not exist).
         * - The callback must return "false", if the value is not unique (already exists).
         */
        unique(callback: (db: Database, value: string, field: FieldContext) => Promise<boolean>): this;
        /**
         * Ensure the value is exists inside the database by self
         * executing a query.
         *
         * - The callback must return "false", if the value exists.
         * - The callback must return "true", if the value does not exist.
         */
        exists(callback: (db: Database, value: string, field: FieldContext) => Promise<boolean>): this;
    }
    interface VineNumber extends VineLucidBindings {
    }
    interface VineString extends VineLucidBindings {
    }
}

Lucid documentation only said that Adonis is extending Vinejs validation with these two methods, unique() and exists(), but no detail on how both work, and I wanted to use both, the former for my registerValidator and the latter for my loginValidator.

At first, when I'm trying to register and login using the API, it works just fine; only when I'm using the user from the factory, both methods work oppositely.

• using an API-registered user, if I try to login, I can get the authentication token, but if I use a factory-created user, I get a database.exists error.
• using an API-registered user, if I tried to re-register the same email, I got a database.unique error, but if it's a factory-created user's email, I can get the auth token, and then there will be another user with the same email inside the database

sc

User models:

const AuthFinder = withAuthFinder(() => hash.use('scrypt'), {
  uids: ['email'],
  passwordColumnName: 'password',
})

export default class User extends compose(BaseModel, AuthFinder) {
  @column({ isPrimary: true })
  declare id: number

  @column()
  declare username: string

  @column()
  declare fullName: string | null

  @column()
  declare email: string

  @column({ serializeAs: null })
  declare password: string

  @column.dateTime({ autoCreate: true })
  declare createdAt: DateTime

  @column.dateTime({ autoCreate: true, autoUpdate: true })
  declare updatedAt: DateTime | null

  @hasMany(() => Thread)
  declare threads: HasMany<typeof Thread>

  static accessTokens = DbAccessTokensProvider.forModel(User)
}

User table:

export default class extends BaseSchema {
  protected tableName = 'users'

  async up() {
    this.schema.createTable(this.tableName, (table) => {
      table.increments('id').notNullable()
      table.string('username', 255).notNullable()
      table.string('full_name', 255).nullable()
      table.string('email', 255).notNullable().unique()
      table.string('password', 180).notNullable()
      table.timestamp('created_at').notNullable()
      table.timestamp('updated_at').nullable()
    })
  }

  async down() {
    this.schema.dropTable(this.tableName)
  }
}

user factory

export const UserFactory = factory
  .define(User, async ({ faker }) => {
    return {
      username: faker.internet.userName(),
      fullName: faker.person.fullName(),
      email: faker.internet.email(),
      password: '12341234',
    }
  })
  .relation('threads', () => ThreadFactory)
  .build()

seeder

export default class extends BaseSeeder {
  async run() {
    // Write your database queries inside the run method
    const category = await CategoryFactory.createMany(5)
    const user = await UserFactory.createMany(2)
    await this.#createThreads(category, user)
  }
  async #createThreads(category: Category[], user: User[]) {
    await ThreadFactory.tap((row) => {
      row.categoryId = category.at(Math.floor(Math.random() * category.length))!.id
      row.userId = user.at(Math.floor(Math.random() * user.length))!.id
    }).createMany(10)
  }
}

auth validator

export const registerValidator = vine.compile(
  vine.object({
    username: vine.string().trim(),
    fullName: vine.string().trim().optional(),
    email: vine
      .string()
      .email()
      .normalizeEmail()
      .unique(async (db, value) => {
        const match = await db.from('users').select('id').where('email', value).first()
        return !match
      }),
    password: vine.string().trim().minLength(8).confirmed(),
  })
)

export const loginValidator = vine.compile(
  vine.object({
    email: vine
      .string()
      .email()
      .normalizeEmail()
      .exists(async (db, value) => {
        const match = await db.from('users').select('id').where('email', value).first()
        return !!match
      }),
    password: vine.string().trim().minLength(8),
  })
)

auth controller

export default class AuthController {
  async register({ request }: HttpContext) {
    const data = await request.validateUsing(registerValidator)
    const user = await User.create(data)

    return User.accessTokens.create(user, ['*'], {
      name: request.input('token_name'),
      expiresIn: '1 days',
    })
  }

  async login({ request }: HttpContext) {
    const { email, password } = await request.validateUsing(loginValidator)
    const user = await User.verifyCredentials(email, password)

    return User.accessTokens.create(user, ['*'], {
      name: request.input('token_name'),
      expiresIn: '1 days',
    })
  }

This is my repo with the branch specifically for this problem: https://github.com/fzhnf/api-endpoint-adonis/tree/feature/User-factory

[fzhnf]

i've got solution, here's the details: adonisjs/lucid#1044