Extending schema classes with unique method

[wswawan]

Base on this documentation about extending schema classes.

rules/unique.ts

export type Options = {
  table: string
  column: string
}

async function unique(value: unknown, options: Options, field: FieldContext) {
  if (typeof value !== 'string') {
    return
  }

  if (!field.isValid) {
    return
  }

  const row = await db
    .from(options.table)
    .select(options.column)
    .where(options.column, value)
    .first()

  if (row) {
    field.report('The {{field}} field is not unique', 'unique', field)
  }
}

export const uniqueRule = vine.createRule(unique)

before extending VineString unique method

code: vine.string().trim().minLength(6).use(uniqueRule({table:'products', column:'code'})

create preload vine
node ace make:preload vine -r

start/vine.ts

declare module '@vinejs/vine' {
  interface VineString {
    unique(options: Options): this
  }
}

VineString.macro('unique', function (this: VineString, options: Options) {
  return this.use(uniqueRule(options))
})

after extending VineString unique method

code: vine.string().trim().minLength(6).unique({table:'products', column:'code'})

results when payload code is not unique

{ 
  "errors": 
    [
       {
           "message": "The code field is not unique",
           "rule": "unique",
           "field": "code"
        }
    ]
}

[namesfang]

// vine.ts
import db from '@adonisjs/lucid/services/db'
import { Dictionary } from '@adonisjs/lucid/types/querybuilder'
import vine, { VineString } from '@vinejs/vine'
import { FieldContext } from '@vinejs/vine/types'

type Options = {
  table: string
  column: string
  // ID excluded when modifying data
  notin?: number[]
  where?: Dictionary<any, string>
}

const uniqueRule = async (value: unknown, options: Options, field: FieldContext) => {
  if (typeof value !== 'string') {
    return
  }

  const { table, column, where, notin } = options

  const query = db.from(table).select('id').where(column, value)

  if (where) {
    query.where(where)
  }
  if (Array.isArray(notin)) {
    query.whereNotIn('id', notin)
  }

  const row = await query.first()
  if (row) {
    field.report('The {{ field }} field is not unique', 'unique', field)
  }
}

const validation = vine.createRule(uniqueRule)

VineString.macro('unique', function (this: VineString, options: Options) {
  return this.use(validation(options))
})

declare module '@vinejs/vine' {
  interface VineString {
    unique(options: Options): this
  }
}

// validation
vine.object({
    label: vine.string().trim().minLength(2).maxLength(6).unique({
      table: 'tags',
      column: 'label',
    }),
})