Введение

joi позволяет описывать ваши данные с помощью простого, интуитивного и удобочитаемого языка.

Пример

const Joi = require('joi');

const schema = Joi.object({
    username: Joi.string()
        .alphanum()
        .min(3)
        .max(30)
        .required(),

    password: Joi.string()
        .pattern(new RegExp('^[a-zA-Z0-9]{3,30}$')),

    repeat_password: Joi.ref('password'),

    access_token: [
        Joi.string(),
        Joi.number()
    ],

    birth_year: Joi.number()
        .integer()
        .min(1900)
        .max(2013),

    email: Joi.string()
        .email({ minDomainSegments: 2, tlds: { allow: ['com', 'net'] } })
})
    .with('username', 'birth_year')
    .xor('password', 'access_token')
    .with('password', 'repeat_password');


schema.validate({ username: 'abc', birth_year: 1994 });
// -> { value: { username: 'abc', birth_year: 1994 } }

schema.validate({});
// -> { value: {}, error: '"username" is required' }

// Also -

try {
    const value = await schema.validateAsync({ username: 'abc', birth_year: 1994 });
}
catch (err) { }

Вышеприведённая схема определяет следующие ограничения:

• username
  • обязательная строка
  • должна содержать только буквенно-цифровые символы
  • длина от 3 до 30 символов
  • должна сопровождаться birth_year
• password
  • необязательная строка
  • должна соответствовать пользовательскому шаблону регулярного выражения
  • не может использоваться вместе с access_token
  • должна сопровождаться repeat_password и быть равной ей
• access_token
  • необязательная, не ограниченная строка или число
• birth_year
  • целое число от 1900 до 2013
• email
  • строка, соответствующая адресу электронной почты
  • должна содержать две части домена, например example.com
  • TLD должен быть .com или .net

Общее использование

Использование состоит из двух шагов:

Во-первых, схема создаётся с использованием предоставленных типов и ограничений:

const schema = Joi.object({
    a: Joi.string()
});

Обратите внимание, что объекты схем joi являются неизменяемыми, что означает, что каждое добавление правила (например, .min(5)) вернёт новый объект схемы.

Во-вторых, значение проверяется по заданной схеме:

const { error, value } = schema.validate({ a: 'a string' });

Если входное значение является допустимым, то error будет undefined. Если входное значение недопустимо, error присваивается объект ValidationError, предоставляющий дополнительную информацию.

Схема может быть обычным объектом JavaScript, где каждый ключ назначен типу joi, или это может быть тип joi напрямую:

const schema = Joi.string().min(10);

Если схема — это тип joi, то schema.validate(value) может быть вызван непосредственно на типе. При передаче объекта схемы, не являющегося типом, модуль преобразует его во внутренний объект типа object(), эквивалентный:

const schema = Joi.object().keys({
    a: Joi.string()
});

При проверке схемы:

• Значения (или ключи в случае объектов) по умолчанию являются необязательными.

  Joi.string().validate(undefined); // validates fine

  Чтобы запретить это поведение, вы можете либо установить схему как required(), либо установить presence в "required" при передаче options:

  Joi.string().required().validate(undefined);
  // or
  Joi.string().validate(undefined, /* options */ { presence: "required" });

• Строки по умолчанию закодированы в utf-8.

• Правила определяются добавлением и вычисляются в порядке, сначала включительные, а затем исключительные.

assert(value, schema, [message], [options])

Проверяет значение по схеме и выбрасывает исключение, если проверка завершилась неудачно, где:

• value - значение для проверки.
• schema - схема проверки. Может быть объектом типа joi или обычным объектом, где каждый ключ назначается объекту типа joi с использованием Joi.compile (будьте осторожны с затратами на многократную компиляцию одних и тех же схем).
• message - необязательный префикс сообщения, добавляемый перед сообщением об ошибке. Может быть также объектом Error.
• options - необязательный объект опций, передаваемый в any.validate

Joi.assert('x', Joi.number());

attempt(value, schema, [message], [options])

Проверяет значение по схеме, возвращает допустимый объект и выбрасывает исключение, если проверка завершилась неудачно, где:

• value - значение для проверки.
• schema - схема проверки. Может быть объектом типа joi или обычным объектом, где каждый ключ назначается объекту типа joi с использованием Joi.compile (будьте осторожны с затратами на многократную компиляцию одних и тех же схем).
• message - необязательный префикс сообщения, добавляемый перед сообщением об ошибке. Может быть также объектом Error.
• options - необязательный объект опций, передаваемый в any.validate

Joi.attempt('x', Joi.number()); // throws error
const result = Joi.attempt('4', Joi.number()); // result -> 4

cache.provision([options])

Создаёт простой кэш LRU для кэширования простых входных данных (undefined, null, строк, чисел и булевых значений), где:

• options - необязательные настройки:
  • max - количество элементов в кэше до удаления наименее используемых. По умолчанию 1000.

checkPreferences(prefs)

Проверяет, являются ли предоставленные настройки допустимыми, где:

• prefs - объект настроек для проверки.

Выбрасывает исключение, если объект prefs недействителен.

Этот метод предназначен для проверки входных данных для методов any.validate() и any.validateAsync(). Проверка не выполняется автоматически по соображениям производительности. Вместо этого вручную проверьте предоставленные настройки один раз и используйте повторно.

compile(schema, [options])

Преобразует литеральное определение схемы в объект схемы joi (или возвращает тот же объект, если это уже объект схемы joi), где:

• schema - определение схемы для компиляции.
• options - необязательные настройки:
  • legacy - если true и предоставленная схема использует более старую версию joi, вернёт откомпилированную схему, совместимую со старой версией. Если false, схема всегда компилируется с использованием текущей версии, а если найдены компоненты более старой схемы, выбрасывается ошибка.

const definition = ['key', 5, { a: true, b: [/^a/, 'boom'] }];
const schema = Joi.compile(definition);

// Same as:

const schema = Joi.alternatives().try(
    Joi.string().valid('key'),
    Joi.number().valid(5),
    Joi.object({
        a: Joi.boolean().valid(true),
        b: Joi.alternatives().try(
            Joi.string().pattern(/^a/),
            Joi.string().valid('boom')
        )
    })
);

defaults(modifier)

Создаёт новый экземпляр joi, применяющий предоставленную функцию модификатора к каждой новой схеме, где:

• modifier - функция с сигнатурой function(schema), которая должна возвращать объект схемы.

const custom = Joi.defaults((schema) => {

    switch (schema.type) {
        case 'string':
            return schema.allow('');
        case 'object':
            return schema.min(1);
        default:
            return schema;
    }
});

const schema = custom.object();   // Returns Joi.object().min(1)

expression(template, [options]) - псевдонимы: x

Генерирует динамическое выражение, используя шаблонную строку, где:

• template - шаблонная строка, использующая синтаксис шаблона.
• options - необязательные настройки, используемые при создании внутренних ссылок. Поддерживает те же опции, что и ref().

Синтаксис шаблона

Шаблонный синтаксис использует {} и {{}} заключённые формулы для ссылки на значения и выполнения числовых и строковых операций. Одинарные фигурные скобки {} оставляют результат формулы как есть, в то время как двойные фигурные скобки {{}} HTML-экранируют результат формулы (если шаблон не используется для сообщений об ошибках и флаг настройки errors.escapeHtml установлен в false).

Если формула представляет собой единственную ссылку, которая начинается с : (например, {:#ref} или {{:#ref}}), её значения будут обернуты в соответствии с настройкой проверки wrap. Переменная #label всегда обернётся в соответствии с настройкой wrap.

Формула использует простой математический синтаксис, такой как a + b * 2, где именованные переменные формулы являются ссылками. Большинство ссылок можно использовать как есть, но некоторые могут создать неоднозначность в синтаксисе формулы и должны быть заключены в [] скобки (например, [.]).

Формулы могут работать только с null, булевыми значениями, числами и строками. Если какая-либо операция включает строку, все другие числа будут преобразованы в строки (поскольку внутренняя реализация использует простые операторы JavaScript). Поддерживаемые операторы: ^, *, /, %, +, -, <, <=, >, >=, ==, !=, &&, ||, и ?? (в этом порядке приоритета).

Имена ссылок могут иметь один из следующих префиксов:

• # - указывает, что переменная ссылается на значение локального контекста. Например, в ошибках это контекст ошибки, а в операциях переименования — группы совпадения регулярного выражения.
• $ - указывает, что переменная ссылается на значение глобального контекста из объекта настроек context , предоставленного в качестве опции функции проверки или установленного с помощью any.prefs().
• любые другие переменные ссылаются на ключ в текущем проверяемом значении.

Синтаксис формулы также поддерживает встроенные функции:

• if(condition, then, otherwise) - возвращает then , если condition истинно, в противном случае otherwise.
• length(item) - возвращает длину массива или строки, количество ключей объекта, в противном случае null.
• msg(code) - встраивает другое сообщение об ошибке.
• number(value) - преобразует значение в число.

И следующие константы:

• null
• true
• false

extend(...extensions)

Создаёт новый настроенный экземпляр модуля joi, где:

• extensions - конфигурации расширений, как описано в Расширения.

Обратите внимание, что исходный модуль joi не изменяется этим.

in(ref, [options])

Создаёт ссылку, которая при разрешении используется как массив значений для сопоставления с правилом, где:

• ref - то же, что и Joi.ref().
• options - то же, что и Joi.ref().

Может использоваться только в правилах, которые поддерживают ссылки in-references.

const schema = Joi.object({
    a: Joi.array().items(Joi.number()),
    b: Joi.number().valid(Joi.in('a'))
});

isError(err)

Проверяет, является ли предоставленный аргумент ошибкой проверки.

Joi.isError(new Error()); // returns false

isExpression(expression)

Проверяет, является ли предоставленный аргумент выражением.

const expression = Joi.x('{a}');
Joi.isExpression(expression); // returns true

isRef(ref)

Проверяет, является ли предоставленный аргумент ссылкой. Полезно, если вы хотите дополнительно обработать сообщения об ошибках.

const ref = Joi.ref('a');
Joi.isRef(ref); // returns true

isSchema(schema, [options])

Проверяет, является ли переданный аргумент схемой joi, где:

• schema - проверяемое значение.
• options - необязательные настройки:
  • legacy - если true, будет определять схемы из более ранних версий joi, в противном случае выведет ошибку. По умолчанию false.

const schema = Joi.any();
Joi.isSchema(schema); // returns true

override

Специальное значение, используемое с any.allow(), any.invalid(), и any.valid(), как первое значение для сброса ранее установленных значений.

Joi.valid(1).valid(Joi.override, 2);

// Same as:

Joi.valid(2);

// Whereas:

Joi.valid(1).valid(2);

// Is the same as:

Joi.valid(1, 2);

ref(key, [options])

Генерирует ссылку на значение указанного ключа. Ссылки разрешаются во время проверки и в порядке зависимости, так что если проверка одного ключа зависит от другого, зависимый ключ проверяется после проверки ссылки.

Ссылки поддерживают следующие аргументы:

• key - целевой объект ссылки. Ссылки могут указывать на соседние ключи (a.b) или родительские ключи (...a.b) с использованием разделителя .. Если ссылка начинается с $, это означает ссылку на контекст, которая ищется в объекте опций context. Ссылка может начинаться с одного или нескольких разделителей, чтобы указать относительную точку начала.
• options - необязательные настройки:
  • adjust - функция со сигнатурой function(value), где value - разрешенное значение ссылки, а возвращаемое значение - скорректированное значение для использования. Например, (value) => value + 5 добавит 5 к разрешенному значению. Обратите внимание, что функция adjust не будет выполнять проверку типа на скорректированном значении, и оно должно соответствовать значению, ожидаемому правилом, в котором используется. Не может быть использовано с map.
  • map - массив пар массивов с форматом [[key, value], [key, value]], используемый для сопоставления разрешенного значения ссылки с другим значением. Если разрешенного значения нет в сопоставлении, оно возвращается как есть. Не может быть использовано с adjust.
  • prefix - переопределяет символы префикса по умолчанию для строки ключа. Может быть установлено на false, чтобы отключить весь синтаксический разбор префиксов (обрабатывать ключи как буквальные строки), или объект со специфическими переопределениями для:
    • global - ссылки на глобально предоставленные предпочтения context. По умолчанию '$'.
    • local - ссылки на контекст, специфичный для ошибки или правила. По умолчанию '#'.
    • root - ссылки на корневое значение, проверяемое в данный момент. По умолчанию '/'.
  • separator - переопределяет разделитель иерархии . по умолчанию. Установите на false, чтобы рассматривать key как буквальное значение.
  • ancestor - если установлено числом, устанавливает относительную точку начала ссылки. Нельзя сочетать с символами префикса разделителя. По умолчанию - префикс ключа ссылки (или 1, если он отсутствует).
  • in - создает внутреннюю ссылку.
  • iterables - когда true, ссылка разрешается путём доступа к картам и множествам.
  • render - когда true, значение ссылки используется вместо его имени в сообщениях об ошибках и рендеринге шаблонов. По умолчанию false.

Обратите внимание, что ссылки могут использоваться только там, где это явно разрешено, например, в правилах valid() или invalid(). Если нужны ссылки на родительские элементы, используйте object.assert().

const schema = Joi.object({
    a: Joi.ref('b.c'),
    b: {
        c: Joi.any()
    },
    c: Joi.ref('$x')
});

await schema.validateAsync({ a: 5, b: { c: 5 } }, { context: { x: 5 } });

Ссылки относительно

По умолчанию ссылка относительна к родителю текущего значения (ключ ссылки ищется внутри родителя). Это означает, что в схеме:

{
    x: {
        a: Joi.any(),
        b: {
            c: Joi.any(),
            d: Joi.ref('c')
        }
    },
    y: Joi.any()
}

Ссылка Joi.ref('c') указывает на c, что является соседним элементом с d - точкой начала ссылки является родитель d, который равен b. Эта схема означает, что d должно быть равно c.

Для ссылки на родительский элемент можно использовать префикс разделителя (используя . в качестве разделителя):

• . - текущее значение
• .. - родитель (то же, что и без префикса)
• ... - прародитель
• .... - прапрародитель
• и т.д.

Например:

{
    x: {
        a: Joi.any(),
        b: {
            c: Joi.any(),
            d: Joi.ref('c'),
            e: Joi.ref('...a'),
            f: Joi.ref('....y')
        }
    },
    y: Joi.any()
}

Другой способ указать относительную точку начала - использовать опцию ancestor, где:

• 0 - текущее значение
• 1 - родитель (это значение по умолчанию, если нет префикса ключа)
• 2 - прародитель
• 3 - прапрародитель
• и т.д.

Например:

{
    x: {
        a: Joi.any(),
        b: {
            c: Joi.any(),
            d: Joi.ref('c', { ancestor: 1 }),
            e: Joi.ref('a', { ancestor: 2 }),
            f: Joi.ref('y', { ancestor: 3 })
        }
    },
    y: Joi.any()
}

Обратите внимание, что если ссылка пытается выйти за пределы корня значения, проверка завершается с ошибкой.

Чтобы указать абсолютный путь от корня значения, используйте префикс /:

{
    x: {
        a: Joi.any(),
        b: {
            c: Joi.ref('/x.a')
        }
    }
}

version

Свойство, отображающее текущую версию joi, используемую в данный момент.

types()

Возвращает объект, где каждый ключ — это обычный тип схемы joi. Полезно для создания сокращений типов с помощью деструктуризации. Обратите внимание, что типы уже сформированы и не нуждаются в вызове как функции (например, string, а не string()).

const Joi = require('joi');
const { object, string } = Joi.types();

const schema = object.keys({
  property: string.min(4)
});

any

Генерирует объект схемы, соответствующий любому типу данных.

const any = Joi.any();
await any.validateAsync('a');

any.type

Получает тип схемы.

const schema = Joi.string();

schema.type === 'string';   // === true

any.allow(...values)

Разрешает значения, где:

• values - один или несколько разрешённых значений, которые могут быть любого типа и будут сопоставлены с проверяемым значением перед применением других правил. Поддерживает ссылки и внутренние ссылки. Если первое значение — Joi.override, оно переопределит любые ранее установленные значения.

Обратите внимание, что этот список разрешённых значений дополняет любые другие разрешённые значения. Чтобы создать эксклюзивный список значений, см. any.valid(value).

const schema = {
    a: Joi.any().allow('a'),
    b: Joi.any().allow('b', 'B')
};

any.alter(targets)

Назначает опции изменения целевых значений схеме, которые применяются при вызове any.tailor(), где:

• targets - объект, где каждый ключ — имя целевого значения, а каждое значение — функция со сигнатурой function(schema), которая возвращает схему.

const schema = Joi.object({
    key: Joi.string()
        .alter({
            get: (schema) => schema.required(),
            post: (schema) => schema.forbidden()
        })  
});

const getSchema = schema.tailor('get');
const postSchema = schema.tailor('post');

any.artifact(id)

Назначает схеме идентификатор артефакта, который включается в результат проверки, если правило прошло проверку, где:

• id - любое значение, отличное от undefined, которое будет возвращено как есть в результате artifacts карты.

const schema = {
    a: [
        Joi.number().max(10).artifact('under'),
        Joi.number().min(11).artifact('over')
    ]
};

any.cache([cache])

Добавляет кэширование в схему, которая будет пытаться кэшировать результаты проверки (успеха и ошибок) входящих данных, где:

• cache - необязательная реализация кэша, совместимая с встроенным кэшем, предоставляемым cache.provision(). Если cache не передан, кэш по умолчанию создаётся с помощью cache.provision() внутри.

Обратите внимание, что решение о том, какие данные кэшировать, остается за реализацией кэша. Встроенный кэш будет хранить только простые значения, такие как undefined, null, строки, числа и булевы значения. Любые изменения в схеме после вызова any.cache() отключит кэширование в результирующей схеме. Это означает, что если .cache() не является последним оператором в определении схемы, кэширование будет отключено.

Чтобы отключить кэширование для всей схемы во время выполнения, установите предпочтение cache на false.

Кэширование игнорирует изменения в предпочтениях во время выполнения. Это означает, что если вы запустите schema.validate() один раз с одним набором предпочтений, а затем снова с другим (например, изменив язык), кешированные результаты будут основаны на первом наборе предпочтений.

Перед использованием кэширования рекомендуется рассмотреть выгоду в производительности, так как это не ускорит каждую схему. Схемы, использующие .valid() список, не получат выгоды от кэширования.

Кэширование будет проигнорировано, если схема использует ссылки за пределами области значения.

Интерфейс кэша

Реализация пользовательского кэша должна реализовать следующий интерфейс:

class {
    set(key, value) {}
    get(key) { return found ? value : undefined; }
}

Обратите внимание, что key и value могут быть чем угодно, включая объекты, массивы и т. д. Рекомендуется ограничить размер кэша при проверке внешних данных, чтобы предотвратить возможность увеличения использования памяти процесса злоумышленником путём отправки большого количества разных данных для проверки.

any.cast(to)

Преобразует проверяемое значение в указанный тип, где:

• to - целевой тип значения. Каждый тип схемы joi поддерживает свой набор целевых преобразований:
  • 'map' - поддерживается типом Joi.object(), преобразует результат в объект Map, содержащий пары ключ-значение объекта.
  • 'number' - поддерживается Joi.boolean() и Joi.date(), преобразует результат в число. Для дат — количество миллисекунд с эпохи, а для булевых значений — 0 для false и 1 для true.
  • 'set' - поддерживается типом Joi.array(), преобразует результат в объект Set, содержащий значения массива.
  • 'string' - поддерживается Joi.binary(), Joi.boolean(), Joi.date(), и Joi.number(), преобразует результат в строку.

any.concat(schema)

Возвращает новый тип, являющийся результатом добавления правил одного типа к другому, где:

• schema - тип joi, который необходимо объединить в текущую схему. Может быть только того же типа, что и тип контекста, или any. Если применяется к типу any, схема может быть любой другой схемой.

const a = Joi.string().valid('a');
const b = Joi.string().valid('b');
const ab = a.concat(b);

any.custom(method, [description])

Добавляет пользовательскую функцию проверки для выполнения произвольного кода, где:

• method - настраиваемая (только синхронная) функция валидации с сигнатурой function(value, helpers), где:
  • value - значение, подлежащее валидации.
  • helpers - объект со следующими вспомогательными функциями:
    • schema - текущая схема.
    • state - текущее состояние валидации.
    • prefs - текущие настройки.
    • original - исходное значение, переданное на валидацию до любых преобразований.
    • error(code, [local]) - метод для генерации кодов ошибок с кодом сообщения и необязательным локальным контекстом.
    • message(messages, [local]) - метод для генерации ошибки с внутренним кодом 'custom' ошибки и предоставленным объектом сообщений для использования в качестве переопределения. Обратите внимание, что это значительно медленнее, чем использование настройки messages , но гораздо проще в написании, когда производительность не важна.
    • warn(code, [local]) - метод для добавления предупреждения с кодом сообщения и необязательным локальным контекстом.

Примечание: если метод не возвращает значение, значение будет сброшено или возвращено как undefined.

const method = (value, helpers) => {

    // Throw an error (will be replaced with 'any.custom' error)
    if (value === '1') {
        throw new Error('nope');
    }

    // Replace value with a new value
    if (value === '2') {
        return '3';
    }

    // Use error to return an existing error code
    if (value === '4') {
        return helpers.error('any.invalid');
    }

    // Override value with undefined to unset
    if (value === '5') {
        return undefined;
    }

    // Return the value unchanged
    return value;
};

const schema = Joi.string().custom(method, 'custom validation');

Возможные ошибки валидации: any.custom

any.default([value])

Устанавливает значение по умолчанию, если исходное значение undefined, где:

• value - значение по умолчанию. Может быть:
  • литеральным значением (строка, число, объект и т. д.).
  • ссылкой ссылки.
  • функцией, возвращающей значение по умолчанию с сигнатурой function(parent, helpers), где:
    • parent - копия объекта, содержащего значение, подлежащее валидации. Обратите внимание, что поскольку указание аргумента parent выполняет клонирование, не объявляйте аргументы формата, если не используете их.
    • helpers - те же, что описаны в any.custom().

При вызове без каких-либо value для типа схемы объекта, значение по умолчанию будет автоматически сгенерировано на основе значений по умолчанию ключей объекта.

Обратите внимание, что если value является объектом, любые изменения в объекте после вызова default() изменят ссылку и любое последующее присваивание. Используйте функцию при установке динамического значения (например, текущего времени).

const generateUsername = (parent, helpers) => {

  return parent.firstname.toLowerCase() + '-' + parent.lastname.toLowerCase();
};

generateUsername.description = 'generated username';

const schema = Joi.object({
    username: Joi.string().default(generateUsername),
    firstname: Joi.string(),
    lastname: Joi.string(),
    created: Joi.date().default(Date.now),
    status: Joi.string().default('registered')
});

const { value } = schema.validate({
    firstname: 'Jane',
    lastname: 'Doe'
});

// value.status === 'registered'
// value.username === 'jane-doe'
// value.created will be the time of validation

Возможные ошибки валидации: any.default

any.describe()

Возвращает объект, представляющий внутреннюю конфигурацию схемы. Полезно для отладки и экспонирования конфигурации схемы другим системам, например, допустимых значений в пользовательском интерфейсе.

const schema = Joi.any().valid('foo', 'bar');
console.log(schema.describe());

Результатом является:

{ type: 'any',
  flags: { only: true },
  valids: [ 'foo', 'bar' ] }

any.description(desc)

Добавляет описание к ключу, где:

• desc - строка описания.

const schema = Joi.any().description('this key will match anything you give it');

any.empty(schema)

Считает любое значение, соответствующее схеме, пустым (undefined).

• schema - любой объект или схема joi для соответствия. Неопределённая схема сбрасывает это правило.

let schema = Joi.string().empty('');
schema.validate(''); // returns { error: null, value: undefined }
schema = schema.empty();
schema.validate(''); // returns { error: "value" is not allowed to be empty, value: '' }

any.error(err)

Переопределяет стандартную ошибку joi на пользовательскую ошибку, если правило не выполнено, где:

• err может быть:
  • экземпляром Error - ошибки переопределения.
  • функцией с сигнатурой function(errors), где errors - массив отчетов о валидации, и она возвращает либо одиночную Error или массив отчетов о валидации.

Не используйте этот метод, если вы просто пытаетесь переопределить сообщение об ошибке — используйте any.message() или any.messages() вместо него. Этот метод предназначен для переопределения ошибки валидации joi и возвращения предоставленного переопределения. Он полезен, когда вы хотите вернуть результат валидации напрямую (например, при использовании с сервером hapi) и хотите вернуть другой код HTTP-ошибки, отличный от 400.

Обратите внимание, что если вы предоставите Error, оно будет возвращено как есть, без изменений и без украшения какими-либо обычными свойствами ошибок. Если валидация завершится неудачей и будет найдена другая ошибка перед переопределением ошибки, будет возвращена эта ошибка, а переопределение будет проигнорировано (если не была установлена настройка abortEarly с значением false). Если вы установите несколько ошибок для одной схемы, используется только последняя ошибка.

const schema = Joi.string().error(new Error('Was REALLY expecting a string'));
schema.validate(3);     // returns Error('Was REALLY expecting a string')

const schema = Joi.object({
    foo: Joi.number().min(0).error((errors) => new Error('"foo" requires a positive number'))
});
schema.validate({ foo: -2 });    // returns new Error('"foo" requires a positive number')

const schema = Joi.object({
    foo: Joi.number().min(0).error((errors) => {

        return new Error('found errors with ' + errors.map((err) => `${err.local.key}(${err.local.limit}) with value ${err.local.value}`).join(' and '));
    })
});
schema.validate({ foo: -2 });    // returns new Error('found errors with foo(0) with value -2')

any.example(example, [options])

Добавляет примеры к схеме, где:

• example - добавляет пример. Обратите внимание, что валидация значения не выполняется.
• options - необязательные настройки:
  • override - если true, заменяет любые существующие примеры. По умолчанию false.

const schema = Joi.string().min(4).example('abcd');

any.external(method, [description])

Добавляет внешнее правило валидации, где:

• method - асинхронная или синхронная функция с сигнатурой function(value, helpers), которая может либо вернуть заменяющее значение, undefined чтобы указать отсутствие изменений, или вызвать ошибку, где:
  • value - копия объекта, содержащего значение, подлежащее валидации.
  • helpers - объект со следующими вспомогательными функциями:
    • schema - текущая схема.
    • linked - если схема является ссылкой, схема, к которой она ссылается.
    • state - текущее состояние валидации.
    • prefs - текущие настройки.
    • original - исходное значение, переданное на валидацию до любых преобразований.
    • error(code, [local]) - метод для генерации кодов ошибок с кодом сообщения и необязательным локальным контекстом.
    • message(messages, [local]) - метод для генерации ошибки с внутренним кодом 'external' ошибки и предоставленным объектом сообщений для использования в качестве переопределения. Обратите внимание, что это значительно медленнее, чем использование настройки messages , но гораздо проще в написании, когда производительность не важна.
    • warn(code, [local]) - метод для добавления предупреждения с кодом сообщения и необязательным локальным контекстом.
• description - необязательная строка, используемая для документирования цели метода.

Обратите внимание, что правила внешней валидации вызываются только после проверки всех других правил валидации для всей схемы (от корневого значения). Это означает, что любые изменения, внесённые правилами внешней валидации, недоступны для других правил валидации во время фазы валидации, не связанной с внешними правилами.

Если валидация схемы завершилась неудачей, правила внешней валидации не вызываются.

any.extract(path)

Возвращает подсхему на основе пути из ключей объекта или идентификаторов схем, где:

• path - строка пути с разделителем точка . или предварительно разделенный массив ключей пути. Ключи должны соответствовать идентификатору подсхемы или ключу объекта (если явно не был установлен идентификатор).

const schema = Joi.object({ foo: Joi.object({ bar: Joi.number() }) });
const number = schema.extract('foo.bar');

//or
const result = schema.extract(['foo', 'bar']); //same as number

any.failover(value)

Устанавливает значение резервного копирования, если исходное значение не проходит валидацию, где:

• value - значение резервного копирования. value поддерживает ссылки. value может быть присвоена функция, возвращающая значение по умолчанию. Если value указана как функция, принимающая один параметр, этот параметр будет объектом контекста, который можно использовать для получения результирующего значения.

Обратите внимание, что если value является объектом, любые изменения в объекте после вызова failover() изменят ссылку и любое последующее присваивание. Используйте функцию при установке динамического значения (например, текущего времени).

Использование функции с одним аргументом выполняет некоторое внутреннее клонирование, что влияет на производительность. Если вам не нужен доступ к контексту, определите функцию без аргументов.

Возможные ошибки валидации: any.failover

any.forbidden()

Помечает ключ как запрещённый, что не позволит использовать значение, кроме undefined. Используется для явного запрета ключей.

const schema = {
    a: Joi.any().forbidden()
};

Возможные ошибки валидации: any.unknown

any.fork(paths, adjuster)

Возвращает новую схему, где каждый из указанных ключей пути был изменён, где:

• paths - массив строк ключей, одиночная строка ключа или массив массивов предварительно разделенных строк ключей. Строки путей ключей используют точку . для обозначения иерархии ключей.
• adjuster - функция с сигнатурой function(schema), которая должна вернуть изменённую схему. Например, (schema) => schema.required().

Метод не изменяет исходную схему.

any.id(id)

Устанавливает идентификатор схемы для доступа к схеме с помощью any.extract(), где:

• id - буквенно-цифровая строка (плюс _) для идентификации схемы.

Если идентификатор не задан, идентификатор схемы по умолчанию соответствует ключу объекта, с которым она связана. Если схема используется в массиве или типе альтернатив и идентификатор не задан, схема недоступна.

any.invalid(...values) - псевдонимы: disallow, not

Запрещает значения, где:

• values - запрещённые значения, которые могут быть любого типа и будут сопоставлены со значением, подлежащим валидации, прежде чем будут применены другие правила. Поддерживает ссылки и внутренние ссылки. Если первое значение является Joi.override, переопределяет любые ранее установленные значения.

const schema = {
    a: Joi.any().invalid('a'),
    b: Joi.any().invalid('b', 'B')
};

Возможные ошибки валидации: any.invalid

any.keep()

То же, что и rule({ keep: true }).

Обратите внимание, что keep() завершит текущий набор правил и не может быть последует другой опцией правила. Используйте rule() для применения нескольких опций правил.

any.label(name)

Переопределяет имя ключа в сообщениях об ошибках.

• name - имя ключа.

const schema = {
    first_name: Joi.string().label('First Name')
};

any.message(message)

То же, что и rule({ message }).

Обратите внимание, что message() завершит текущий набор правил и не может быть последует другой опцией правила. Используйте rule() для применения нескольких опций правил.

any.messages(messages)

То же, что и any.prefs({ messages }).

Обратите внимание, что в то время как any.message() применяется только к последнему правилу или набору правил, any.messages() применяется ко всему схеме.

any.meta(meta)

Присоединяет метаданные к ключу, где:

• meta - объект метаданных для присоединения.

const schema = Joi.any().meta({ index: true });

any.note(...notes)

Аннотирует ключ, где:

• notes - строка заметки или несколько заметок в качестве отдельных аргументов.

const schema = Joi.any().note('this is special', 'this is important');

any.only()

Требует, чтобы проверенное значение соответствовало предоставленным any.allow() значениям. Не оказывает влияния, когда вызывается вместе с any.valid(), так как уже устанавливает требования. При использовании с any.allow() преобразует его в any.valid().

any.optional()

Помечает ключ как необязательный, что позволит undefined в качестве значений. Используется для аннотации схемы для читабельности, так как все ключи по умолчанию необязательны.

Примечание: это не позволяет null значения. Для этого используйте any.allow(value). Или оба!

const schema = Joi.any().optional();

any.prefs(options) - псевдонимы: preferences, options

Переопределяет глобальные validate() опции для текущего ключа и всех вложенных ключей, где:

• options - объект с теми же необязательными ключами, что и any.validate().

const schema = Joi.any().prefs({ convert: false });

any.presence(mode)

Устанавливает режим присутствия для схемы, где:

• mode - может быть одним из 'optional', 'required', или 'forbidden'

То же, что и вызов any.optional(), any.required(), или any.forbidden().

any.raw([enabled])

Выводит исходное неизменённое значение вместо приведённого значения, где:

• enabled - если true, возвращается исходный результат, в противном случае — проверенное значение. По умолчанию true.

Обратите внимание, что сырое значение применяется только после проверки, и любые ссылки на значение используют проверенное значение, а не сырое.

const timestampSchema = Joi.date().timestamp();
timestampSchema.validate('12376834097810'); // { error: null, value: Sat Mar 17 2362 04:28:17 GMT-0500 (CDT) }

const rawTimestampSchema = Joi.date().timestamp().raw();
rawTimestampSchema.validate('12376834097810'); // { error: null, value: '12376834097810' }

any.required() - псевдонимы: exist

Помечает ключ как обязательный, что не позволит undefined в качестве значения. Все ключи по умолчанию необязательны.

const schema = Joi.any().required();

Возможные ошибки проверки: any.required

any.result(mode)

Устанавливает режим результата, где:

• mode - один из 'raw' (то же, что и any.raw()) или 'strip' (то же, что и any.strip()).

any.rule(options)

Применяет набор опций правил к текущему набору правил или последнему добавленному правилу, где:

• options - правила для применения, где:
  • keep - если true, правила не будут заменены тем же уникальным правилом позже. Например, Joi.number().min(1).rule({ keep: true }).min(2) сохранит оба min() правила вместо того, чтобы позднее правило заменило первое. По умолчанию false.
  • message - одна строка сообщения или объект сообщений, где каждый ключ — код ошибки, а соответствующая строка сообщения — значение. Объект аналогичен messages используемому в качестве опции в any.validate(). Строки могут быть простыми сообщениями или шаблоном сообщения.
  • warn - если true, преобразует любую ошибку, сгенерированную набором правил, в предупреждения.

При применении опций правил используется последнее правило (например, min()) за исключением случаев, когда определён активный набор правил (например, $.min().max()) в этом случае опции применяются ко всем предоставленным правилам. После вызова rule(), предыдущие правила больше нельзя изменить, и любой активный набор правил завершается.

Изменения правил могут быть применены только к поддерживаемым правилам. Большинство any методов не поддерживают изменения правил, потому что они реализованы с использованием флагов схемы (например, required()) или специальной внутренней реализации (например, valid()). В этих случаях используйте метод any.messages(), чтобы переопределить коды ошибок для ошибок, которые вы хотите настроить.

any.ruleset - псевдонимы: $

Инициализирует набор правил для применения нескольких опций правил. Набор завершается, когда вызывается rule(), keep(), message() или warn().

const schema = Joi.number().ruleset.min(1).max(10).rule({ message: 'Number must be between 1 and 10' });

const schema = Joi.number().$.min(1).max(10).rule({ message: 'Number must be between 1 and 10' });

any.shared(schema)

Регистрирует схему, которая будет использоваться потомками текущей схемы в ссылках на именованные ссылки, где:

• schema - схема joi со свойством id.

  const schema = Joi.object({
      a: [Joi.string(), Joi.link('#x')],
      b: Joi.link('#type.a')
  })
      .shared(Joi.number().id('x'))
      .id('type');

any.strict(isStrict)

Режим строгости устанавливает options.convert опции в false, что предотвращает приведение типов для текущего ключа и всех вложенных ключей.

• isStrict - включен ли режим строгости или нет. По умолчанию true.

const schema = Joi.any().strict();

any.strip([enabled])

Помечает ключ для удаления из результирующего объекта или массива после проверки для очистки вывода, где:

• enabled - если true, значение удаляется, в противном случае проверенное значение сохраняется. По умолчанию true.

const schema = Joi.object({
    username: Joi.string(),
    password: Joi.string().strip()
});

schema.validate({ username: 'test', password: 'hunter2' }); // result.value = { username: 'test' }

const schema = Joi.array().items(Joi.string(), Joi.any().strip());

schema.validate(['one', 'two', true, false, 1, 2]); // result.value = ['one', 'two']

any.tag(...tags)

Аннотирует ключ, где:

• tags - строка тега или несколько тегов (каждый как аргумент).

const schema = Joi.any().tag('api', 'user');

any.tailor(targets)

Применяет все назначенные изменения целевых значений к копии схемы, которые были применены через any.alter(), где:

• targets - одна строка целевого значения или массив или строки целевых значений для применения.

const schema = Joi.object({
    key: Joi.string()
        .alter({
            get: (schema) => schema.required(),
            post: (schema) => schema.forbidden()
        })  
});

const getSchema = schema.tailor('get');
const postSchema = schema.tailor(['post']);

any.unit(name)

Аннотирует ключ, где:

• name - имя единицы измерения значения.

const schema = Joi.number().unit('milliseconds');

any.valid(...values) - псевдонимы: equal

Добавляет предоставленные значения в список разрешенных значений и помечает их как единственно допустимые значения, где:

• values - одно или несколько разрешенных значений, которые могут быть любого типа и будут сопоставлены с проверяемым значением перед применением других правил. Поддерживает ссылки и внутренние ссылки. Если первое значение — Joi.override, оно переопределит все ранее заданные значения. Если единственное значение — Joi.override, также удалит флаг only из схемы.

const schema = {
    a: Joi.any().valid('a'),
    b: Joi.any().valid('b', 'B')
};

Возможные ошибки проверки: any.only

any.validate(value, [options])

Проверяет значение с помощью текущей схемы и опций, где:

• value - значение, подлежащее валидации.
• options - необъект с необязательными ключами:
  • abortEarly - при true, останавливает валидацию на первой ошибке, в противном случае возвращает все найденные ошибки. По умолчанию true.
  • allowUnknown - при true, разрешает объекту содержать неизвестные ключи, которые игнорируются. По умолчанию false.
  • cache - при true, кеширование схем включено (для схем с явными правилами кеширования). По умолчанию true.
  • context - предоставляет внешний набор данных для использования в ссылках. Может быть установлен только как внешний параметр для validate() и не используется с any.prefs().
  • convert - при true, пытается привести значения к требуемым типам (например, строку к числу). По умолчанию true.
  • dateFormat - устанавливает формат строки, используемый при преобразовании дат в строки в сообщениях об ошибках и при приведении типов. Варианты:
    • 'date' - строка даты.
    • 'iso' - строка даты и времени в формате ISO. Это значение по умолчанию.
    • 'string' - строка даты и времени по умолчанию для JavaScript.
    • 'time' - строка времени.
    • 'utc' - строка даты и времени в формате UTC.
  • debug - при true, результаты валидации и ошибки снабжаются свойством debug, которое включает массив шагов валидации, использованных для получения возвращаемого результата. По умолчанию false.
  • errors - настройки форматирования сообщений об ошибках:
    • escapeHtml - при true, шаблоны сообщений об ошибках будут экранировать специальные символы в HTML-сущности для обеспечения безопасности. По умолчанию false.
    • label - определяет значение, используемое для установки контекстного переменной label:
      • 'path' - полный путь к проверяемому значению. Это значение по умолчанию.
      • 'key' - ключ проверяемого значения.
      • false - удаляет любой префикс метки из сообщения об ошибке, включая "".
    • language - предпочтительный код языка для сообщений об ошибках. Значение сопоставляется с ключами в корне объекта messages, а затем с кодом ошибки как дочерним ключом. Может ссылаться на значение, глобальный контекст или локальный контекст, который является корневым значением, переданным функции валидации. Обратите внимание, что ссылки на значение обычно не являются тем, что вам нужно, так как они перемещаются по структуре значения относительно места возникновения ошибки. Вместо этого используйте глобальный контекст или абсолютное значение (например, Joi.ref('/variable'));
    • render - при false, пропускает отрисовку шаблонов ошибок. Полезно, когда сообщения об ошибках генерируются в другом месте для экономии времени обработки. По умолчанию true.
    • stack - при true, основное сообщение об ошибке будет содержать стек вызовов, в противном случае он будет отключен. По умолчанию false по соображениям производительности. Не оказывает влияния на платформы, отличные от V8/node.js, так как использует API стека вызовов.
    • wrap - переопределяет способ обертывания значений (например, [] вокруг массивов, "" вокруг меток и переменных с префиксом :). Каждый ключ может быть установлен на строку с одним (одинаковым символом перед и после значения) или двумя символами (первый символ перед и второй символ после) или false для отключения обертывания:
      • label - символы, используемые вокруг {#label} ссылок. По умолчанию '"'.
      • array - символы, используемые вокруг значений массива. По умолчанию '[]'.
      • string - символы, используемые вокруг каждого значения строки в массиве. По умолчанию false.
    • wrapArrays - если true, значения массивов в сообщениях об ошибках оборачиваются в []. По умолчанию true.
  • externals - если false, внешние правила, установленные с помощью any.external(), игнорируются, что необходимо для игнорирования внешних проверок в синхронном режиме (или выбрасывается исключение). По умолчанию true.
  • messages - переопределяет отдельные сообщения об ошибках. По умолчанию переопределение отключено ({}). Используйте '*' код ошибки в качестве универсального для всех кодов ошибок, для которых не предоставлено сообщение в переопределении. Сообщения используют те же правила, что и шаблоны. Переменные в двойных фигурных скобках {{var}} экранируются в HTML, если опция errors.escapeHtml установлена в true.
  • noDefaults - при true, значения по умолчанию не применяются. По умолчанию false.
  • nonEnumerables - при true, входные данные клонируются с поверхностным копированием, чтобы включить неперечисляемые свойства. По умолчанию false.
  • presence - устанавливает требования наличия по умолчанию. Поддерживаемые режимы: 'optional', 'required', и 'forbidden'. По умолчанию 'optional'.
  • skipFunctions - при true, игнорируются неизвестные ключи со значением типа функция. По умолчанию false.
  • stripUnknown - удаляет неизвестные элементы из объектов и массивов. По умолчанию false.
    • при object:
      • arrays - устанавливается в true для удаления неизвестных элементов из массивов.
      • objects - устанавливается в true для удаления неизвестных ключей из объектов.
    • при true, это эквивалентно { arrays: false, objects: true }.

Возвращает объект со следующими ключами:

• value - валидированное и нормализованное значение.
• error - сообщения об ошибках валидации, если они есть.
• warning - сгенерированные предупреждения, если таковые имеются.
• artifacts - объект Map, содержащий артефакты успешных правил и соответствующие массивы путей.

const schema = Joi.object({
    a: Joi.number()
});

const value = {
    a: '123'
};

const result = schema.validate(value);
// result -> { value: { "a" : 123 } }

any.validateAsync(value, [options])

Асинхронно проверяет значение с использованием текущей схемы и параметров, где:

• value - значение, подлежащее валидации.
• options - необязательный объект, как описано в any.validate(), со следующими дополнительными параметрами:
  • artifacts - при true, артефакты возвращаются вместе со значением (то есть { value, artifacts }). По умолчанию false.
  • warnings - при true, предупреждения возвращаются вместе со значением (то есть { value, warning }). По умолчанию false.

Возвращает Promise, который разрешается в валидированное значение, когда значение корректно. Если значение корректно и параметры warnings или debug установлены в true, возвращает объект { value, warning, debug }. Если проверка завершается неудачей, обещание отклоняется с ошибкой валидации.

const schema = Joi.object({
    a: Joi.number()
});

const value = {
    a: '123'
};

try {
  const value = await schema.validateAsync(value);
  // value -> { "a" : 123 }
}
catch (err) {
}

any.warn()

Аналогично rule({ warn: true }).

Обратите внимание, что warn() завершит текущий набор правил и за ним не может следовать другой параметр правила. Используйте rule() для применения нескольких параметров правил.

any.warning(code, [context])

Генерирует предупреждение, где:

• code - код предупреждения. Может быть существующим кодом ошибки или настраиваемым кодом. Если используется настраиваемый код, соответствующее определение сообщения об ошибке должно быть настроено через any.message(), any.prefs() или параметр валидации messages.
• context - необязательный контекстный объект.

При вызове any.validateAsync(), установите параметр warning в true для включения предупреждений. Предупреждения сообщаются отдельно от ошибок вместе со значением результата через ключ warning (то есть { value, warning }). Предупреждения всегда включаются при вызове any.validate().

const schema = Joi.any()
    .warning('custom.x', { w: 'world' })
    .message({ 'custom.x': 'hello {#w}!' });

const { value, error, warning } = schema.validate('anything');

// value -> 'anything';
// error -> null
// warning -> { message: 'hello world!', details: [...] }

// or

try {
    const { value, warning } = await schema.validateAsync('anything', { warnings: true });
    // value -> 'anything';
    // warning -> { message: 'hello world!', details: [...] }
}
catch (err) { }

any.when([condition], options)

Добавляет условия, которые оцениваются во время валидации и изменяют схему перед ее применением к значению, где:

• condition - имя ключа, ссылка или схема. Если опущено, по умолчанию Joi.ref('.').
• options - объект с:
  • is - условие, выраженное как схема joi. Все, что не является схемой joi, будет преобразовано с помощью Joi.compile. По умолчанию схема условия is допускает значения undefined. Используйте .required() для переопределения. Например, используйте is: Joi.number().required() для гарантии, что ссылка joi существует и является числом.
  • not - обратная версия is (then и otherwise имеют обратные роли).
  • then - если условие истинно, используемая схема joi.
  • otherwise - если условие ложно, используемая схема joi.
  • switch - массив из { is, then } условий, которые оцениваются относительно condition. Последний элемент массива также может содержать otherwise.
  • break - останавливает обработку всех других условий, если правило приводит к then, otherwise, или switch соответствию.

Если condition является ссылкой:

• если is, not, и switch отсутствуют, is по умолчанию Joi.invalid(null, false, 0, '').required() (значение должно быть истинным).
• is и not не могут использоваться вместе.
• требуется одно из then, otherwise, или switch.
• нельзя использовать is или then с switch.
• нельзя указать otherwise как внутри последнего switch утверждения, так и вне его.

Если condition является схемой:

• нельзя указать is или switch.
• требуется одно из then или otherwise.

Когда is, then, или otherwise присваиваются литеральные значения, значения компилируются в переопределяющие схемы ('x' компилируется в Joi.valid(Joi.override, 'x')). Это означает, что они будут переопределять любую базовую схему, к которой применяется правило. Чтобы добавить литеральное значение, используйте явный формат Joi.valid('x').

Примечания:

• неверная комбинация изменений схемы (например, попытка добавить правила строк или тип числа) приведет к тому, что валидация выбросит ошибку.
• поскольку схема создается во время валидации, это может значительно повлиять на производительность. Сгенерированные во время выполнения схемы кэшируются, но первый раз каждая генерация займет больше времени, чем после кэширования.

const schema = {
    a: Joi.any()
        .valid('x')
        .when('b', { is: Joi.exist(), then: Joi.valid('y'), otherwise: Joi.valid('z') })
        .when('c', { is: Joi.number().min(10), then: Joi.forbidden() }),
    b: Joi.any(),
    c: Joi.number()
};

Или со схемой:

const schema = Joi.object({
    a: Joi.any().valid('x'),
    b: Joi.any()
})
    .when(Joi.object({ b: Joi.exist() }).unknown(), {
        then: Joi.object({
            a: Joi.valid('y')
        }),
        otherwise: Joi.object({
            a: Joi.valid('z')
        })
});

Обратите внимание, что этот стиль гораздо полезнее, когда вся ваша схема зависит от значения одного из её свойств, или если вы обнаруживаете, что повторяете проверку для многих ключей объекта. Например, для проверки этой логики:

const schema = Joi.object({
    type: Joi.string()
        .valid('A', 'B', 'C')
        .required(),              // required if type == 'A'
        
    foo: Joi.when('type', {
        is: 'A',
        then: Joi.string()
        .valid('X', 'Y', 'Z')
        .required()
    }),                           // required if type === 'A' and foo !== 'Z'
    
    bar: Joi.string()
})
    .when(Joi.object({ type: Joi.valid('A'), foo: Joi.not('Z') }).unknown(), {
        then: Joi.object({ bar: Joi.required() })
    });

В качестве альтернативы, если вы хотите указать определённый тип, такой как string, array, и т.д., вы можете сделать это так:

const schema = {
    a: Joi.valid('a', 'b', 'other'),
    other: Joi.string()
        .when('a', { is: 'other', then: Joi.required() }),
};

Если вам нужно проверить дочерний ключ внутри вложенного объекта на основе значения его брата, вы можете сделать это так:

const schema = Joi.object({
    a: Joi.boolean().required(),
    b: Joi.object()
        .keys({
            c: Joi.string(),
            d: Joi.number().required()
        })
        .required()
        .when('a', {
            is: true,
            then: Joi.object({ c: Joi.required() })		// b.c is required only when a is true
        })
});

Если вы хотите проверить один ключ на основе существования другого ключа, вы можете сделать это следующим образом (обратите внимание на использование required()):

const schema = Joi.object({
    min: Joi.number(),
    max: Joi.number().when('min', {
        is: Joi.number().required(),
        then: Joi.number().greater(Joi.ref('min')),
    }),
});

Для оценки нескольких значений по одному ссылочному объекту:

const schema = Joi.object({
    a: Joi.number().required(),
    b: Joi.number()
        .when('a', {
            switch: [
                { is: 0, then: Joi.valid(1) },
                { is: 1, then: Joi.valid(2) },
                { is: 2, then: Joi.valid(3) }
            ],
            otherwise: Joi.valid(4)
        })
});

Или короче:

const schema = Joi.object({
    a: Joi.number().required(),
    b: Joi.number()
        .when('a', [
            { is: 0, then: 1 },
            { is: 1, then: 2 },
            { is: 2, then: 3, otherwise: 4 }
        ])
});

alternatives

Генерирует тип, который будет соответствовать одной из предоставленных альтернативных схем с помощью метода try(). Если схемы не добавлены, тип не будет соответствовать ни одному значению, кроме undefined.

Поддерживает те же методы типа any().

Альтернативы могут быть выражены с помощью сокращённой записи [].

const alt = Joi.alternatives().try(Joi.number(), Joi.string());
// Same as [Joi.number(), Joi.string()]

Обратите внимание, что числовые строки будут приводиться к числам в примере выше (см. any.strict()).

Возможные ошибки валидации: alternatives.any, alternatives.all, alternatives.one, alternatives.types, alternatives.match

alternatives.conditional(condition, options)

Добавляет условный тип альтернативной схемы, либо на основе значения другого ключа, либо схемы, заглядывающей в текущее значение, где:

• condition - имя ключа или ссылка, или схема.
• options - объект с:
  • is - условие, выраженное как схема joi. Всё, что не является схемой joi, будет преобразовано с помощью Joi.compile.
  • not - отрицательная версия is (then и otherwise имеют обратные роли).
  • then - если условие истинно, используемая схема joi.
  • otherwise - если условие ложно, используемая схема joi.
  • switch - массив из { is, then } условий, которые вычисляются относительно condition. Последний элемент массива также может содержать otherwise.

Если condition является ссылкой:

• если is, not, и switch отсутствуют, is по умолчанию Joi.invalid(null, false, 0, '').required() (значение должно быть истинным).
• is и not не могут использоваться вместе.
• требуется один из then, otherwise, или switch.
• нельзя использовать is или then с switch.
• нельзя указать otherwise как внутри последнего утверждения switch, так и снаружи.

Если condition является схемой:

• нельзя указать is или switch.
• требуется один из then или otherwise.

Когда is, then, или otherwise назначены буквальным значениям, значения компилируются в схемы-переопределения ('x' компилируется в Joi.valid(Joi.override, 'x')). Это означает, что они переопределят любую базовую схему, к которой применяется правило. Для добавления литерального значения используйте явный формат Joi.valid('x').

Обратите внимание, что alternatives.conditional() отличается от any.when(). При использовании any.when() вы получаете составную схему всех соответствующих условий, тогда как alternatives.conditional() будет использовать первую соответствующую схему, игнорируя другие условные операторы.

const schema = {
    a: Joi.alternatives().conditional('b', { is: 5, then: Joi.string(), otherwise: Joi.number() }),
    b: Joi.any()
};

const schema = Joi.alternatives().conditional(Joi.object({ b: 5 }).unknown(), {
    then: Joi.object({
        a: Joi.string(),
        b: Joi.any()
    }),
    otherwise: Joi.object({
        a: Joi.number(),
        b: Joi.any()
    })
});

Обратите внимание, что conditional() добавляет только дополнительные альтернативы для проверки и не влияет на общий тип. Установка правила required() на отдельную альтернативу не будет применяться к общему ключу. Например, это определение a:

const schema = {
    a: Joi.alternatives().conditional('b', { is: true, then: Joi.required() }),
    b: Joi.boolean()
};

Не делает a обязательным ключом, когда b равно true. Вместо этого он сообщает валидатору попытаться сопоставить значение с любым, что не является undefined. Однако, так как Joi.alternatives() само по себе допускает undefined, правило не выполняет превращение a в обязательное значение. Это правило эквивалентно Joi.alternatives([Joi.required()]) когда b равно true, что позволит любое значение, включая undefined.

Для достижения желаемого результата используйте:

const schema = {
    a: Joi.when('b', { is: true, then: Joi.required() }),
    b: Joi.boolean()
};

alternatives.match(mode)

Требует, чтобы проверяемое значение соответствовало определённому набору предоставленных alternative.try() схем, где:

• mode - режим соответствия, который может быть одним из:
  • 'any' - сопоставить любую предоставленную схему. Это значение по умолчанию.
  • 'all' - сопоставить все предоставленные схемы. Обратите внимание, что это игнорирует любые преобразования, выполняемые сопоставляемыми схемами, и возвращает исходное значение независимо от предпочтения convert.
  • 'one' - сопоставить одну и только одну из предоставленных схем.

Примечание: Не может быть объединено с alternatives.conditional().

Возможные ошибки валидации: alternatives.any, alternatives.all, alternatives.one

alternatives.try(...schemas)

Добавляет альтернативный тип схемы для попытки сопоставления с проверяемым значением, где:

• schemas - альтернативные типы joi, каждый как отдельный аргумент.

const alt = Joi.alternatives().try(Joi.number(), Joi.string());
await alt.validateAsync('a');

array

Генерирует объект схемы, который соответствует типу данных массива. Обратите внимание, что значения undefined внутри массивов по умолчанию запрещены, но могут быть разрешены с использованием sparse().

Поддерживает те же методы типа any().

const array = Joi.array().items(Joi.string().valid('a', 'b'));
await array.validateAsync(['a', 'b', 'a']);

Возможные ошибки валидации: array.base

array.has(schema)

Проверяет, что схема проходит валидацию по крайней мере одного из значений в массиве, где:

• schema - правила валидации, необходимые для удовлетворения проверки. Если schema включает ссылки, они разрешаются относительно элемента массива, который тестируется, а не значения целевого ref.

const schema = Joi.array().items(
  Joi.object({
    a: Joi.string(),
    b: Joi.number()
  })
).has(Joi.object({ a: Joi.string().valid('a'), b: Joi.number() }))

Возможные ошибки валидации: array.hasKnown, array.hasUnknown

array.items(...types)

Перечисляет типы, разрешённые для значений массива, где:

• types - один или более объектов схемы joi для проверки каждого элемента массива.

Если заданный тип .required(), то должен быть соответствующий элемент в массиве. Если тип .forbidden(), то он не может появляться в массиве. Обязательные элементы могут быть добавлены несколько раз, чтобы указать, что должно быть найдено несколько элементов. Ошибки будут содержать количество элементов, которые не совпали. Любой несовпавший элемент, имеющий метку, будет упомянут явно.

const schema = Joi.array().items(Joi.string(), Joi.number()); // array may contain strings and numbers
const schema = Joi.array().items(Joi.string().required(), Joi.string().required()); // array must contain at least two strings
const schema = Joi.array().items(Joi.string().valid('not allowed').forbidden(), Joi.string()); // array may contain strings, but none of those strings can match 'not allowed'
const schema = Joi.array().items(Joi.string().label('My string').required(), Joi.number().required()); // If this fails it can result in `[ValidationError: "value" does not contain [My string] and 1 other required value(s)]`

Возможные ошибки валидации: array.excludes, array.includesRequiredBoth, array.includesRequiredKnowns, array.includesRequiredUnknowns, array.includes

array.length(limit)

Устанавливает точное количество элементов в массиве, где:

• limit - допустимое число элементов массива или ссылка.

const schema = Joi.array().length(5);

const schema = Joi.object({
  limit: Joi.number().integer().required(),
  numbers: Joi.array().length(Joi.ref('limit')).required()
});

Возможные ошибки валидации: array.length, array.ref

array.max(limit)

Устанавливает максимальное количество элементов в массиве, где:

• limit - максимальное допустимое число элементов массива или ссылка.

const schema = Joi.array().max(10);

const schema = Joi.object({
  limit: Joi.number().integer().required(),
  numbers: Joi.array().max(Joi.ref('limit')).required()
});

Возможные ошибки валидации: array.max, array.ref

array.min(limit)

Устанавливает минимальное количество элементов в массиве, где:

• limit - минимальное допустимое число элементов массива или ссылка.

const schema = Joi.array().min(2);

const schema = Joi.object({
  limit: Joi.number().integer().required(),
  numbers: Joi.array().min(Joi.ref('limit')).required()
});

Возможные ошибки валидации: array.min, array.ref

array.ordered(...type)

Перечисляет типы в порядке следования для значений массива, где:

• types - один или более объектов схемы joi для проверки каждого элемента массива в порядке следования.

Если заданный тип .required(), то должен быть соответствующий элемент с той же позицией в массиве. Ошибки будут содержать количество элементов, которые не совпали. Любой несовпавший элемент, имеющий метку, будет упомянут явно.

const schema = Joi.array().ordered(Joi.string().required(), Joi.number().required()); // array must have first item as string and second item as number
const schema = Joi.array().ordered(Joi.string().required()).items(Joi.number().required()); // array must have first item as string and 1 or more subsequent items as number
const schema = Joi.array().ordered(Joi.string().required(), Joi.number()); // array must have first item as string and optionally second item as number

Возможные ошибки валидации: array.excludes, array.includes, array.orderedLength

array.single([enabled])

Позволяет проверять отдельные значения по правилам, как если бы они были предоставлены в виде массива.

enabled можно использовать со значением falsy, чтобы вернуться к стандартному поведению.

const schema = Joi.array().items(Joi.number()).single();
schema.validate([4]); // returns `{ error: null, value: [ 4 ] }`
schema.validate(4); // returns `{ error: null, value: [ 4 ] }`

Возможные ошибки валидации: array.excludes, array.includes

array.sort([options])

Требует, чтобы массив соответствовал указанному порядку сортировки, где:

• options - необязательные настройки:
  • order - порядок сортировки. Допустимые значения:
    • 'ascending' - сортировать массив по возрастанию. Это значение по умолчанию.
    • 'descending' - сортировать массив по убыванию.
  • by - имя ключа или ссылка для сортировки объектов массива по этому ключу. По умолчанию используется всё значение.

Примечания:

• Если предпочтение convert равно true, массив изменяется для соответствия требуемому порядку сортировки.
• Значения undefined всегда помещаются в конец массива независимо от порядка сортировки.
• Можно сортировать только элементы или значения ключей элементов строкового и числового типов.

Возможные ошибки валидации: array.sort, array.sort.unsupported, array.sort.mismatching

array.sparse([enabled])

Позволяет этому массиву быть разреженным. enabled можно использовать со значением falsy, чтобы вернуться к стандартному поведению.

let schema = Joi.array().sparse(); // undefined values are now allowed
schema = schema.sparse(false); // undefined values are now denied

Возможные ошибки валидации: array.sparse

array.unique([comparator, [options]])

Требует, чтобы значения массива были уникальными, где:

• comparator - необязательный пользовательский comparator, который может быть:
  • Функцией, принимающей 2 параметра для сравнения. Эта функция должна возвращать значение, указывающее, равны ли 2 параметра, и вы отвечаете за корректную работу этой функции, любые Error будут распространяться вверх по стеку Joi.
  • Строкой в точечной нотации, представляющей путь к элементу для проверки уникальности. Любой отсутствующий путь будет считаться неопределённым и может существовать только один раз.
• options - необязательные настройки:
  • ignoreUndefined - если true, неопределённые значения для точечной нотации компаратора не приведут к ошибке валидации массива по уникальности. По умолчанию false.
  • separator - переопределяет разделитель иерархии по умолчанию .. Установите значение false, чтобы обрабатывать key как литеральное значение.

Примечание: помните, что при использовании пользовательской функции компаратора, в качестве параметров могут передаваться разные типы данных, в зависимости от установленных правил для элементов.

Обратите внимание, что глубокое сравнение выполняется для элементов массива типа object, ожидается снижение производительности при этом типе операций.

const schema = Joi.array().unique();

const schema = Joi.array().unique((a, b) => a.property === b.property);

const schema = Joi.array().unique('customer.id');

let schema = Joi.array().unique('identifier');

schema.validate([{}, {}]);
// ValidationError: "value" position 1 contains a duplicate value

schema = Joi.array().unique('identifier', { ignoreUndefined: true });

schema.validate([{}, {}]);
// error: null

Возможные ошибки валидации: array.unique

binary

Генерирует объект схемы, соответствующий типу данных Buffer. Если опция валидации convert включена (по умолчанию включена), строка будет преобразована в Buffer, если указано.

Поддерживает те же методы, что и тип any().

const schema = Joi.binary();

Возможные ошибки валидации: binary.base

binary.encoding(encoding)

Устанавливает формат кодировки строки, если входная строка преобразуется в буфер, где:

• encoding - схема кодирования.

const schema = Joi.binary().encoding('base64');

binary.length(limit)

Указывает точную длину буфера:

• limit - разрешенный размер буфера или ссылка.

const schema = Joi.binary().length(5);

Возможные ошибки валидации: binary.length, binary.ref

binary.max(limit)

Указывает максимальную длину буфера, где:

• limit - максимальный размер буфера или ссылка.

const schema = Joi.binary().max(10);

Возможные ошибки валидации: binary.max, binary.ref

binary.min(limit)

Указывает минимальную длину буфера, где:

• limit - минимальный размер буфера или ссылка.

const schema = Joi.binary().min(2);

Возможные ошибки валидации: binary.min, binary.ref

boolean

Генерирует объект схемы, который соответствует типу данных boolean. Также может быть вызван через bool(). Если опция валидации convert включена (по умолчанию включена), строка ("true" или "false") будет преобразована в boolean, если указано.

Поддерживает те же методы, что и тип any().

const boolean = Joi.boolean();

await boolean.validateAsync(true); // Valid
await boolean.validateAsync(1);    // Throws

Возможные ошибки валидации: boolean.base

boolean.falsy(...values)

Позволяет рассматривать дополнительные значения как допустимые булевы значения, преобразуя их в false во время валидации. Требует, чтобы опция валидации convert была true.

Сравнения строк по умолчанию регистронезависимые, см. boolean.sensitive() для изменения этого поведения.

const boolean = Joi.boolean().falsy('N');
await boolean.validateAsync('N'); // Valid

boolean.sensitive([enabled])

Ограничивает значения до truthy и falsy, а также 'true' и 'false' стандартных преобразований (если не в strict() режиме) для соответствия регистрозависимым образом, где:

• enabled - при false, разрешает регистронезависимое сравнение. По умолчанию true.

const schema = Joi.boolean().truthy('yes').falsy('no').sensitive();

boolean.truthy(...values)

Позволяет рассматривать дополнительные значения как допустимые булевы значения, преобразуя их в true во время валидации. Требует, чтобы опция валидации convert была true.

Сравнения строк по умолчанию регистронезависимые, см. boolean.sensitive() для изменения этого поведения.

const boolean = Joi.boolean().truthy('Y');
await boolean.validateAsync('Y'); // Valid

date

Генерирует объект схемы, соответствующий типу данных date (а также строке JavaScript date или количеству миллисекунд). Если опция валидации convert включена (по умолчанию включена), строка или число будут преобразованы в Date, если указано. Обратите внимание, что некоторые недопустимые строки дат будут приняты, если их можно привести к допустимым датам (например, '2/31/2019' будет преобразовано в '3/3/2019' ) с помощью внутренней реализации JS Date.parse().

Примечание: При использовании joi в среде браузера, от парсинга строк дат с конструктором Date (и Date.parse(), работающим аналогично) настоятельно рекомендуется отказаться из-за различий и несоответствий браузеров. Например, '1-1-1910' является допустимым в Chrome, но вызовет ошибку в Safari.

Поддерживает те же методы, что и тип any().

const date = Joi.date();
await date.validateAsync('12-21-2012');

Возможные ошибки валидации: date.base, date.strict

date.greater(date)

Указывает, что значение должно быть больше date (или ссылки).

const schema = Joi.date().greater('1-1-1974');

Примечания: 'now' может быть передано вместо date, чтобы всегда сравнивать относительно текущей даты, позволяя явно гарантировать, что дата находится в прошлом или в будущем. При использовании 'now', обратите внимание, что это включает текущее время, и два значения сравниваются на основе их метки времени UTC в миллисекундах.

const schema = Joi.date().greater('now');

const schema = Joi.object({
  from: Joi.date().required(),
  to: Joi.date().greater(Joi.ref('from')).required()
});

Возможные ошибки валидации: date.greater, date.ref

date.iso()

Требует, чтобы строковое значение имело допустимый формат даты ISO 8601.

const schema = Joi.date().iso();

Возможные ошибки валидации: date.format

date.less(date)

Указывает, что значение должно быть меньше date (или ссылки).

const schema = Joi.date().less('12-31-2020');

Примечания: 'now' может быть передано вместо date, чтобы всегда сравнивать относительно текущей даты, позволяя явно гарантировать, что дата находится в прошлом или в будущем.

const schema = Joi.date().less('now');

const schema = Joi.object({
  from: Joi.date().less(Joi.ref('to')).required(),
  to: Joi.date().required()
});

Возможные ошибки валидации: date.less, date.ref

date.max(date)

Указывает самую позднюю разрешенную дату, где:

• date - самая поздняя разрешенная дата или ссылка.

const schema = Joi.date().max('12-31-2020');

Примечания: 'now' может быть передано вместо date, чтобы всегда сравнивать относительно текущей даты, позволяя явно гарантировать, что дата находится в прошлом или в будущем.

const schema = Joi.date().max('now');

const schema = Joi.object({
  from: Joi.date().max(Joi.ref('to')).required(),
  to: Joi.date().required()
});

Возможные ошибки валидации: date.max, date.ref

date.min(date)

Указывает самую раннюю разрешенную дату, где:

• date - самая ранняя разрешенная дата или ссылка.

const schema = Joi.date().min('1-1-1974');

Примечания: 'now' может быть передано вместо date, чтобы всегда сравнивать относительно текущей даты, позволяя явно гарантировать, что дата находится в прошлом или в будущем.

const schema = Joi.date().min('now');

const schema = Joi.object({
  from: Joi.date().required(),
  to: Joi.date().min(Joi.ref('from')).required()
});

Возможные ошибки валидации: date.min, date.ref

date.timestamp([type])

Требуется, чтобы значение было интервалом временных меток с момента времени Unix.

• type - тип временной метки (разрешенные значения unix или javascript [по умолчанию])

const schema = Joi.date().timestamp(); // defaults to javascript timestamp
const schema = Joi.date().timestamp('javascript'); // also, for javascript timestamp (milliseconds)
const schema = Joi.date().timestamp('unix'); // for unix timestamp (seconds)

Возможные ошибки валидации: date.format

function - наследуется от object

Генерирует объект схемы, соответствующий типу функции.

Поддерживает те же методы типа object(). Обратите внимание, что валидация ключей функции приведет к клонированию функции. Хотя функция сохранит свой прототип и замыкание, она потеряет значение свойства length (будет установлено в 0).

const func = Joi.function();
await func.validateAsync(function () {});

Возможные ошибки валидации: object.base

function.arity(n)

Определяет арность функции, где:

• n - ожидаемая арность.

const schema = Joi.function().arity(2);

Возможные ошибки валидации: function.arity

function.class()

Требует, чтобы функция была классом.

const schema = Joi.function().class();

Возможные ошибки валидации: function.class

function.maxArity(n)

Определяет максимальную арность функции, где:

• n - ожидаемая максимальная арность.

const schema = Joi.function().maxArity(3);

Возможные ошибки валидации: function.maxArity

function.minArity(n)

Определяет минимальную арность функции, где:

• n - ожидаемая минимальная арность.

const schema = Joi.function().minArity(1);

Возможные ошибки валидации: function.minArity

link(ref)

Ссылки на другой узел схемы и повторно использует его для проверки, обычно для творческих рекурсивных схем, где:

• ref - ссылка на связанный узел схемы. Нельзя ссылаться на себя или своих потомков, а также на другие ссылки. Ссылки могут быть выражены в относительных терминах, таких как ссылки на значения (Joi.link('...')), в абсолютных терминах от корня схемы во время выполнения (Joi.link('/a')), или используя идентификаторы схем неявно с помощью ключей объекта или явно с помощью any.id() (Joi.link('#a.b.c')).

Поддерживает методы типа any().

При сочетании с правилами any.when(), правила применяются после разрешения ссылки к связанной схеме.

Именованные ссылки рекомендуются для большинства случаев использования, так как они легко поддаются пониманию и анализу, а при ошибках выводится сообщение об ошибке с недействительной ссылкой. Относительные ссылки часто трудно отследить, особенно при вложенности в массивы или правилах альтернатив. Абсолютные ссылки полезны только тогда, когда схема никогда не повторно используется внутри другой схемы, так как корень — это корень схемы во время выполнения, а не текущий корень схемы.

Обратите внимание, что именованные ссылки должны быть найдены в непосредственном предке ссылки. Имена ищутся путем итерации по цепочке схем от текущей схемы до корня. Чтобы добраться до дяди или двоюродного брата, нужно использовать имя общего предка, например, дедушки, а затем спуститься по дереву.

Ссылки разрешаются один раз (на период выполнения) и результат схемы кэшируется. Если вы повторно используете ссылку в разных местах, в первый раз при разрешении во время выполнения результат будет использоваться всеми другими экземплярами. Если вы хотите, чтобы каждая ссылка разрешалась относительно места ее использования, используйте отдельный оператор Joi.link() в каждом месте или установите флаг relative().

Именованные ссылки:

const person = Joi.object({
    firstName: Joi.string().required(),
    lastName: Joi.string().required(),
    children: Joi.array()
        .items(Joi.link('#person'))
})
  .id('person');

Относительные ссылки:

const person = Joi.object({
    firstName: Joi.string().required(),
    lastName: Joi.string().required(),
    children: Joi.array()
        .items(Joi.link('...'))
        // . - the link
        // .. - the children array
        // ... - the person object
});

Абсолютные ссылки:

const person = Joi.object({
    firstName: Joi.string().required(),
    lastName: Joi.string().required(),
    children: Joi.array()
        .items(Joi.link('/'))
});

link.ref(ref)

Инициализирует схему после создания для случаев, когда схема должна быть создана сначала, а затем инициализирована. Если ref не был передан в конструктор, необходимо вызвать link.ref(), прежде чем использовать его.

Вызовет ошибку во время проверки, если не инициализирован (например, Joi.link() вызван без ссылки и link.ref() не вызван).

const schema = Joi.object({
    a: [Joi.string(), Joi.number()],
    b: Joi.link().ref('#type.a')
})
    .id('type');

link.concat(schema)

То же, что и any.concat(), но схема объединяется после разрешения ссылки, что позволяет объединять схемы того же типа, что и разрешенная ссылка. Вызовет исключение во время проверки, если объединенные типы несовместимы.

number

Генерирует объект схемы, соответствующий числовому типу данных (а также строкам, которые можно преобразовать в числа).

По умолчанию допускаются только безопасные числа, см. number.unsafe().

Если опция проверки convert включена (по умолчанию), строка преобразуется в число, если указано. Также, если convert включена и используется number.precision(), значение будет преобразовано в указанный precision.

Infinity и -Infinity по умолчанию недопустимы, можно изменить это поведение, вызвав allow(Infinity, -Infinity).

Поддерживает те же методы типа any().

const number = Joi.number();
await number.validateAsync(5);

Возможные ошибки валидации: number.base, number.infinity

number.greater(limit)

Указывает, что значение должно быть больше limit или ссылки.

const schema = Joi.number().greater(5);

const schema = Joi.object({
  min: Joi.number().required(),
  max: Joi.number().greater(Joi.ref('min')).required()
});

Возможные ошибки валидации: number.greater, number.ref

number.integer()

Требует, чтобы число было целым (без дробной части).

const schema = Joi.number().integer();

Возможные ошибки валидации: number.base

number.less(limit)

Указывает, что значение должно быть меньше limit или ссылки.

const schema = Joi.number().less(10);

const schema = Joi.object({
  min: Joi.number().less(Joi.ref('max')).required(),
  max: Joi.number().required()
});

Возможные ошибки валидации: number.less, number.ref

number.max(limit)

Указывает максимальное значение, где:

• limit - максимально допустимое значение или ссылка.

const schema = Joi.number().max(10);

const schema = Joi.object({
  min: Joi.number().max(Joi.ref('max')).required(),
  max: Joi.number().required()
});

Возможные ошибки валидации: number.max, number.ref

number.min(limit)

Указывает минимальное значение, где:

• limit - минимально допустимое значение или ссылка.

const schema = Joi.number().min(2);

const schema = Joi.object({
  min: Joi.number().required(),
  max: Joi.number().min(Joi.ref('min')).required()
});

Возможные ошибки валидации: number.min, number.ref

number.multiple(base)

Указывает, что значение должно быть кратно base (или ссылке):

const schema = Joi.number().multiple(3);

Примечания: Joi.number.multiple(base) использует оператор остатка (%) для определения, является ли число кратным другому числу. Поэтому существуют обычные ограничения оператора остатка Javascript. Результаты с десятичными/дробными числами могут быть некорректными.

Возможные ошибки валидации: number.multiple, number.ref

number.negative()

Требуется, чтобы число было отрицательным.

const schema = Joi.number().negative();

Возможные ошибки валидации: number.negative

number.port()

Требуется, чтобы число было TCP-портом, то есть находилось в диапазоне от 0 до 65535.

const schema = Joi.number().port();

Возможные ошибки валидации: number.port

number.positive()

Требуется, чтобы число было положительным.

const schema = Joi.number().positive();

Возможные ошибки валидации: number.positive

number.precision(limit)

Указывает максимальное количество знаков после запятой, где:

• limit - максимально допустимое количество знаков после запятой.

const schema = Joi.number().precision(2);

Возможные ошибки валидации: number.integer

number.sign(sign)

Требуется, чтобы число было отрицательным или положительным, где: sign - одно из значений 'negative' или 'positive'.

Возможные ошибки валидации: number.negative, number.positive

number.unsafe([enabled])

По умолчанию числа должны быть в пределах безопасного диапазона JavaScript (Number.MIN_SAFE_INTEGER & Number.MAX_SAFE_INTEGER), и при передаче строки должны быть преобразованы без потери информации. Вы можете разрешить небезопасные числа на свой страх и риск, вызвав number.unsafe().

Параметры:

• enabled - необязательный параметр, по умолчанию true, который позволяет сбросить поведение небезопасности, передав ложное значение.

const safeNumber = Joi.number();
safeNumber.validate(90071992547409924);
// error -> "value" must be a safe number

const unsafeNumber = Joi.number().unsafe();
unsafeNumber.validate(90071992547409924);
// error -> null
// value -> 90071992547409920

Возможные ошибки валидации: number.unsafe

object

Генерирует объект схемы, соответствующий типу данных объект. По умолчанию разрешаются любые дочерние ключи.

Поддерживает те же методы типа any().

const object = Joi.object({
    a: Joi.number().min(1).max(10).integer(),
    b: 'some string'
});

await object.validateAsync({ a: 5 });

Обратите внимание, что когда тип схемы объекта передается в качестве входного значения в другой метод joi (например, элемент массива) или устанавливается как определение ключа, конструктор Joi.object() может быть опущен. Например:

const schema = Joi.array().items({ a: Joi.string() });

Возможные ошибки валидации: object.base

object.and(...peers, [options])

Определяет взаимосвязь «все или ничего» между ключами, где если один из ключей-партнёров присутствует, все они также требуются.

• peers - имена ключей строк, все из которых, если присутствуют, обязательны.
• options - необязательные настройки:
  • separator - переопределяет разделитель иерархии по умолчанию .. Установите в false, чтобы рассматривать key как литеральное значение.
  • isPresent - функция, переопределяющая проверку на пустое значение по умолчанию. По умолчанию: (resolved) => resolved !== undefined

const schema = Joi.object({
    a: Joi.any(),
    b: Joi.any()
}).and('a', 'b');

Возможные ошибки валидации: object.and

object.append([schema])

Добавляет разрешенные ключи объекта, где:

• schema - необязательный объект, где каждый ключ назначен объекту типа joi. Если schema имеет значение null, undefined или {}, изменения не будут применены. Использует object.keys([schema]) для добавления ключей.

// Validate key a
const base = Joi.object({
    a: Joi.number()
});
// Validate keys a, b.
const extended = base.append({
    b: Joi.string()
});

object.assert(subject, schema, [message])

Проверяет утверждение, где:

• subject - имя ключа, ссылка или выражение шаблона для проверки. Обратите внимание, что ссылка разрешается относительно самого объекта как значения, что означает, что если вы хотите сослаться на ключ проверяемого объекта, вы должны префикс пути ссылки с ..
• schema - правила валидации, необходимые для удовлетворения утверждения. Если schema содержит ссылки, они разрешаются относительно значения объекта, а не значения целевого объекта subject.
• message - необязательное удобочитаемое сообщение, используемое при невыполнении утверждения. По умолчанию "не удалось пройти тест утверждения".

const schema = Joi.object({
    a: {
        b: Joi.string(),
        c: Joi.number()
    },
    d: {
        e: Joi.any()
    }
}).assert('.d.e', Joi.ref('a.c'), 'equal to a.c');

Возможные ошибки валидации: object.assert

object.instance(constructor, [name])

Требует, чтобы объект был экземпляром заданного конструктора, где:

• constructor - функция конструктора, экземпляром которой должен быть объект.
• name - альтернативное имя для использования в ошибках валидации. Это полезно, когда функция конструктора не имеет имени.

const schema = Joi.object().instance(RegExp);

Возможные ошибки валидации: object.instance

object.keys([schema])

Устанавливает или расширяет разрешенные ключи объекта, где:

• schema - необязательный объект, где каждый ключ назначен объекту типа joi. Если schema имеет значение {}, разрешенные ключи отсутствуют. Если schema имеет значение null или undefined, любой ключ разрешен. Если schema - объект с ключами, ключи добавляются к любым ранее определенным ключам (но сужает выбор, если все ключи были разрешены ранее). По умолчанию 'undefined', что разрешает любой дочерний ключ.

const base = Joi.object().keys({
    a: Joi.number(),
    b: Joi.string()
});
// Validate keys a, b and c.
const extended = base.keys({
    c: Joi.boolean()
});

Возможные ошибки валидации: object.unknown

object.length(limit)

Определяет точное количество ключей в объекте, где или ссылка:

• limit - количество разрешенных ключей объекта.

const schema = Joi.object().length(5);

Возможные ошибки валидации: object.length, object.ref

object.max(limit)

Определяет максимальное количество ключей в объекте, где:

• limit - максимальное количество разрешенных ключей объекта или ссылка.

const schema = Joi.object().max(10);

Возможные ошибки валидации: object.max, object.ref

object.min(limit)

Определяет минимальное количество ключей в объекте, где:

• limit - минимальное количество разрешенных ключей или ссылка.

const schema = Joi.object().min(2);

Возможные ошибки валидации: object.min, object.ref

object.nand(...peers, [options])

Определяет взаимоотношения между ключами, где не все пары могут присутствовать одновременно, где:

• peers - имена ключей, если один присутствует, другие не могут присутствовать все.
• options - необязательные настройки:
  • separator - переопределяет разделитель иерархии по умолчанию .. Установите в false, чтобы рассматривать key как литеральное значение.
  • isPresent - функция, переопределяющая проверку на пустое значение по умолчанию. По умолчанию: (resolved) => resolved !== undefined

const schema = Joi.object({
    a: Joi.any(),
    b: Joi.any()
}).nand('a', 'b');

Возможные ошибки валидации: object.nand

object.or(...peers, [options])

Определяет взаимоотношения между ключами, где одна из пар необходима (и более одной разрешена), где:

• peers - имена ключей, по крайней мере один из которых должен присутствовать.
• options - необязательные настройки:
  • separator - переопределяет разделитель иерархии по умолчанию .. Установите в false, чтобы рассматривать key как литеральное значение.
  • isPresent - функция, переопределяющая проверку на пустое значение по умолчанию. По умолчанию: (resolved) => resolved !== undefined

const schema = Joi.object({
    a: Joi.any(),
    b: Joi.any()
}).or('a', 'b');

Возможные ошибки валидации: object.missing

object.oxor(...peers, [options])

Определяет исключительные взаимоотношения между набором ключей, где только один разрешен, но ни один не обязателен, где:

• peers - имена исключительных ключей, которые не должны появляться вместе, но где ни один не является обязательным.
• options - необязательные настройки:
  • separator - переопределяет разделитель иерархии по умолчанию .. Установите в false, чтобы рассматривать key как литеральное значение.
  • isPresent - функция, переопределяющая проверку на пустое значение по умолчанию. По умолчанию: (resolved) => resolved !== undefined

const schema = Joi.object({
    a: Joi.any(),
    b: Joi.any()
}).oxor('a', 'b');

Возможные ошибки валидации: object.oxor

object.pattern(pattern, schema, [options])

Определяет правила валидации для неизвестных ключей, соответствующих шаблону, где:

• pattern - шаблон, который может быть либо регулярным выражением, либо схемой joi, которая будет проверена на соответствие именам неизвестных ключей. Обратите внимание, что если шаблон является регулярным выражением, чтобы оно соответствовало всему имени ключа, оно должно начинаться с ^ и заканчиваться $.
• schema - объект схемы, соответствующий ключам, должен пройти проверку.
• options - настройки параметров:
  • fallthrough - если true, несколько соответствующих шаблонов проверяются на соответствие ключу, иначе, как только найден шаблон соответствия, другие шаблоны не сравниваются. По умолчанию false.
  • matches - схема массива joi, используемая для проверки массива соответствующих ключей. Например, Joi.object().pattern(/\d/, Joi.boolean(), { matches: Joi.array().length(2) }) потребует два соответствующих ключа. Если схема matches не является схемой типа массив, она будет преобразована в Joi.array().items(matches). Если схема matches содержит ссылки, они разрешаются относительно предков следующим образом:
    • self - массив соответствующих ключей (Joi.ref('.length'))
    • parent - значение объекта, содержащего ключи (Joi.ref('a'))

const schema = Joi.object({
    a: Joi.string()
}).pattern(/\w\d/, Joi.boolean());

// OR

const schema = Joi.object({
    a: Joi.string()
}).pattern(Joi.string().min(2).max(5), Joi.boolean());