Валидация данных

Kodzero SDK предоставляет встроенную валидацию данных на основе библиотеки Validno.

Определение схемы

При создании модели укажите схему для валидации:

interface User {
  _id: string | null
  name: string
  email: string
  age?: number
}

const userSchema = {
  _id: { type: String },
  name: { type: String, required: true },
  email: { type: String, required: true },
  age: { type: Number }
}

const User = kodzero.createModel<User>({
  collection: 'users',
  schema: userSchema
})

Поддерживаемые типы

Тип	Описание
String	Строка
Number	Число
Boolean	Булево значение
Date	Дата
Array	Массив
Object	Объект

Опции валидации

required

Поле обязательно для заполнения:

const schema = {
  name: { type: String, required: true }
}

default

Значение по умолчанию:

const schema = {
  status: { type: String, default: 'active' },
  createdAt: { type: Date, default: () => new Date() }
}

Валидация экземпляра

Метод validate()

Используйте метод validate() для проверки данных:

const user = new User({
  _id: null,
  name: 'Иван',
  email: ''  // пустой email
})

const result = user.validate()

if (result.ok) {
  console.log('Данные корректны')
} else {
  console.log('Ошибки:', result.errors)
  console.log('Ошибки (строка):', result.joinErrors())
}

Возвращаемое значение

{
  ok: boolean,        // true если валидация прошла успешно
  errors: string[],   // массив ошибок
  joinErrors: () => string  // метод для объединения ошибок в строку
}

Примеры валидации

Валидация перед сохранением

const user = new User({
  _id: null,
  name: '',
  email: 'invalid-email'
})

const validation = user.validate()

if (!validation.ok) {
  // Показать ошибки пользователю
  alert(validation.joinErrors())
  return
}

// Сохранить если валидно
await user.save()

Вложенные объекты

interface Profile {
  _id: string | null
  user: {
    name: string
    contact: {
      email: string
      phone?: string
    }
  }
}

const profileSchema = {
  _id: { type: String },
  user: {
    name: { type: String, required: true },
    contact: {
      email: { type: String, required: true },
      phone: { type: String }
    }
  }
}

const Profile = kodzero.createModel<Profile>({
  collection: 'profiles',
  schema: profileSchema
})

React форма с валидацией

import { useState } from 'react'

function UserForm() {
  const [formData, setFormData] = useState({
    name: '',
    email: ''
  })
  const [errors, setErrors] = useState<string[]>([])

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault()

    const user = new User({
      _id: null,
      ...formData
    })

    const validation = user.validate()

    if (!validation.ok) {
      setErrors(validation.errors)
      return
    }

    setErrors([])
    await user.save()
    alert('Пользователь создан!')
  }

  return (
    <form onSubmit={handleSubmit}>
      {errors.length > 0 && (
        <div className="errors">
          {errors.map((error, i) => (
            <p key={i} className="error">{error}</p>
          ))}
        </div>
      )}

      <input
        type="text"
        placeholder="Имя"
        value={formData.name}
        onChange={e => setFormData({...formData, name: e.target.value})}
      />

      <input
        type="email"
        placeholder="Email"
        value={formData.email}
        onChange={e => setFormData({...formData, email: e.target.value})}
      />

      <button type="submit">Создать</button>
    </form>
  )
}

Vue 3 компонент с валидацией

<script setup lang="ts">
import { ref, reactive } from 'vue'

const formData = reactive({
  name: '',
  email: ''
})

const errors = ref<string[]>([])
const loading = ref(false)

async function handleSubmit() {
  const user = new User({
    _id: null,
    ...formData
  })

  const validation = user.validate()

  if (!validation.ok) {
    errors.value = validation.errors
    return
  }

  errors.value = []
  loading.value = true

  try {
    await user.save()
    alert('Пользователь создан!')
  } finally {
    loading.value = false
  }
}
</script>

<template>
  <form @submit.prevent="handleSubmit">
    <div v-if="errors.length" class="errors">
      <p v-for="error in errors" :key="error" class="error">
        {{ error }}
      </p>
    </div>

    <input v-model="formData.name" placeholder="Имя" />
    <input v-model="formData.email" type="email" placeholder="Email" />

    <button type="submit" :disabled="loading">
      {{ loading ? 'Сохранение...' : 'Создать' }}
    </button>
  </form>
</template>

Валидация без схемы

Если модель создана без схемы, метод validate() выбросит ошибку:

const User = kodzero.createModel<User>({
  collection: 'users'
  // schema не указана
})

const user = new User({ ... })
user.validate() // Error: Schema is not defined

Ручная проверка данных

Вы также можете использовать библиотеку Validno напрямую:

import Schema from 'validno'

const schema = new Schema({
  name: { type: String, required: true },
  email: { type: String, required: true }
})

const data = { name: 'Иван', email: '' }
const result = schema.validate(data)

if (!result.ok) {
  console.log(result.joinErrors())
}

Подробнее о возможностях Validno читайте в документации Validno.

Следующие шаги

• Обработка ошибок
• API Reference