Adding a Custom Validation Predicate

[carcigenicate]

I have a schema, and for a particular field on the schema, I'd like to supplement schema validation with a custom function. I Googled this, and unfortunately, Google's AI fed me some BS that got my hopes up, but its answer demonstrates what I'm looking for:

const MySchema = Type.Object({
  customValidationField: Type.Unsafe<string>({
    validate: (value: unknown) => {
      // Implement your custom validation logic
      return typeof value === 'string' && value.length > 5;
    },
  }),
});

This doesn't even allow the schema to compile/be checked (it throws a TypeCompilerUnknownTypeError/ValueCheckUnknownTypeError exception because their switches don't include Unsafe as an option), but it's exactly what I'm looking for. I want to run a supplemental predicate to check the value, since the type of validation needed for this field can't be represented via a schema (it requires parsing a string and then doing a search through the parsed object to determine if some traits hold).

Is anything like this possible via Typebox? Of course, I could just add some supplemental validation outside of Typebox, but that leads to the unfortunate case where if some code bypasses my supplemental validation and checks against Typebox directly, the extra validation might be missed. I'd ideally like the predicate to be tied to the field so any time Typebox does validation, the predicate will run and be taken into consideration.

Thank you.

[sinclairzx81]

@carcigenicate Hello,

I have a schema, and for a particular field on the schema, I'd like to supplement schema validation with a custom function. I Googled this, and unfortunately, Google's AI fed me some BS that got my hopes up, but its answer demonstrates what I'm looking for:

You shouldn't need a custom type for this, the following should work in TypeBox 0.34.x

import { Type } from '@sinclair/typebox' // 0.34.x

const MySchema = Type.Object({
  customValidationField: Type.String({ minLength: 6 }), // > 5
});

But if you are using TypeBox 1.0, you can also do this.

import Type from 'typebox' // 1.0

const MySchema = Type.Object({
  customValidationField: Type.Refine(Type.String(), value => value.length > 5),
})

But for simple constraints such as this, you should use { minLength: 6 } because JavaScript logic doesn't serialize to JSON Schema, but minLength does.

Hope this helps
S

[carcigenicate]

Hello @sinclairzx81,

Thank you for the lightning fast reply and this library.

Sorry, that example was bad. I just copy and pasted what the AI gave me as an example. I should have made it more complex to fit my needs better. By "demonstrates what I'm looking for", I just meant that it calls a function during validation.

Instead of just checking the type and length of a string, I need to parse the string to an AST, then walk the AST to ensure that it's valid and within some custom bounds, and then return a boolean to indicate if it passed custom validation. It's very custom logic.

From further searching, I think I might need to add AJV to my project. This does what I need:

import { Type, Static } from '@sinclair/typebox';
import { Check, Value } from '@sinclair/typebox/value';
import { Ajv } from 'ajv';

const ajv = new Ajv();

(async () => {
  ajv.addKeyword({
    keyword: 'checked',
    // I want a custom function like this to be called during validation
    validate: (schemaValue, value, schema, context) => {
      return true /* Some custom validation */;
    }
  });

  const MySchema = Type.Object({
    customValidationField: Type.String({
      checked: true,
    }),
  });

  type MyType = Static<typeof MySchema>;

  const validData: MyType = { customValidationField: 'successful string' };
  const invalidData: MyType = { customValidationField: 'failing string' };

  const validator = ajv.compile(MySchema);

  console.log(validator(validData));
  console.log(validator(invalidData));
})();

Can you confirm if AJV is required for custom validation logic, or is there some way of doing this using Typebox alone? And I'm using 0.34.33.

It looks like that might be supported by Refine if I'm reading your example correctly? I might need to update to 1 at some point then.

Thank you.

[sinclairzx81]

Can you confirm if AJV is required for custom validation logic, or is there some way of doing this using Typebox alone? And I'm using 0.34.33.

You can use either TypeBox or Ajv for custom validation, but I would recommend using Ajv as the mechanisms for custom validation aligns better to how TypeBox 1.0 will be handling things in future. Here is how you can express custom validation schematics with 0.34.33 (but assumes you have setup the Ajv addKeyword correctly)

TypeScript Link Here

import { Type, Static, TSchema } from '@sinclair/typebox'

// ---------------------------------------------------------------
// TChecked
//
// This type just models whatever keyword you're adding to Ajv
// via the ajv.addKeyword function. 
//
// ---------------------------------------------------------------
export interface TChecked<Value = unknown> extends TSchema { 
  static: Value // required for inference in typebox 0.34.x 
  checked: true
  validate: (value: unknown) => boolean
}
export function Checked<Value>(validate: (value: unknown) => boolean): TChecked<Value> {
  // return whatever structure is required to match ajv.addKeyword(...)
  return { checked: true, validate } as never
}

// Usage

type MySchema = Static<typeof MySchema>

const MySchema = Type.Object({
    customValidationField: Checked<string>(value => 
        typeof value === 'string' && value.length > 5
    ),
});

[carcigenicate]

Thank you for the verification.

[carcigenicate]

Nvm, I figured it out. In case anyone else needs to support async validators, $async can be added to the second argument:

const MySchema = Type.Object({
  customValidationField: Checked(),
}, {
  $async: true
});

That emulates what's shown here: https://ajv.js.org/guide/async-validation.html