String formats validation and custom formats?

[waynesbrain]

Hello, I'm using Cabidela in a Cloudflare Pages worker project but I don't think it handles any string-format validation yet does it?

I see that pattern validation is implemented, but I want to register a named string format and supply a validator function for it similar to how you do it for TypeBox and Ajv. Just curious if you could tell me how you might expose that feature?

It looks like the correct place to add calls to a validator would be around here. Beyond that, I guess you would add a mapping of string-format validators in the CabidelaOptions, something like formats: Record<string, (value: string) => boolean | string>;?

My main question about any possible future format validators is the function signature. I suppose I would be safe just returning a boolean to Cabidela, but that would limit the resulting error messages to '${pathToString(needle.path)}' is not a valid '${format}'. and it would be nice, if the validator returned a string, to do something like '${pathToString(needle.path)}' is not a valid '${format}'. (${result}) where result would be the string returned from the validator.

For now I'll start by making my own validator functions just return booleans to be safe.

EDIT: The benefit of just returning a bool will be that I can use some code from ajv-formats, so I guess that should be the standard anyway.

This addition was pretty straightforward, but if you're taking pull requests let me know and I'll send one.

[waynesbrain]

It was easy to make compatibility with ajv-formats using their Format configuration signature from ajv/lib/types EXCEPT for their async validation signatures.

I guess I could see the need for some async validation for certain types of values, but for the most part my needs are met with the synchronous validation that I added to this code.

if (needle.schema.hasOwnProperty("format")) {
  const { format } = needle.schema;
  const valid = isValidStringFormat(
    this.options.formats!,
    format,
    resolvedObject,
  );
  if (!valid) {
    this.throw(
      `${pathToString(needle.path)}' is not a valid '${format}'.`,
      needle,
    );
  }
}

// ...

function isValidStringFormat(
  formats: Record<string, Format>,
  format: string,
  value: string,
) {
  const defined = formats[format];
  let valid = !defined || defined === true;
  if (!valid) {
    let validate: FormatValidator<string> | string | RegExp | undefined;
    if (typeof defined === "function") {
      validate = defined;
    } else {
      validate = (defined as FormatDefinition<string>).validate ?? defined;
    }
    if (validate instanceof RegExp) {
      try {
        valid = validate.test(value);
      } catch (e) {}
    } else {
      if (typeof validate === "function") {
        valid = validate(value);
      } else {
        // CONSIDER: Use string-type validator differently; as keys...
        valid = value === validate;
      }
    }
  }
  return valid;
}

Type Format type above comes from a formats.ts file that I forked from ajv shown below. (It might be a good idea to move isValidStringFormat into this file...)

/**
 * @file Forked from https://github.com/ajv-validator/ajv-formats
 *
 * Forked [at](https://github.com/ajv-validator/ajv-formats/blob/4ca86d21bd07571a30178cbb3714133db6eada9a/src/formats.ts)
 * since we're not using Ajv.
 *
 * See https://github.com/cloudflare/cabidela/issues/12
 */

// #region Ajv Types copied from Ajv
//
// - Copied from https://github.com/ajv-validator/ajv/blob/82735a15826a30cc51e97a1bbfb59b3d388e4b98/lib/types/index.ts#L200
//
// To replace type imports from "ajv" and "ajv/dist/types" in original source.

export type FormatValidator<T extends string | number> = (data: T) => boolean;

export type FormatCompare<T extends string | number> = (
  data1: T,
  data2: T,
) => number | undefined;

export interface FormatDefinition<T extends string | number> {
  type?: T extends string ? "string" | undefined : "number";
  validate: FormatValidator<T> | (T extends string ? string | RegExp : never);
  async?: false | undefined;
  compare?: FormatCompare<T>;
}

export type AddedFormat =
  | true
  | RegExp
  | FormatValidator<string>
  | FormatDefinition<string>
  | FormatDefinition<number>;

export type Format = AddedFormat | string;

// #endregion

// ... contents of github.com/ajv-validator/ajv/blob/82735a15826a30cc51e97a1bbfb59b3d388e4b98/lib/types/index.ts

[waynesbrain]

Why doesn't anybody love me?