ajv#ValidateFunction TypeScript Examples

makePreprocessActionCreator =
  <A, AA, T extends ActionName>(
    t: T,
    validate: ValidateFunction<AA> | undefined,
    clean: (d: A) => AA
  ) =>
  (formData: A) =>
  (year: TaxYear): Save<T, AA> => ({
    type: t,
    year,
    formData:
      validate !== undefined
        ? validators.checkType(clean(formData), validate)
        : { ...formData, ...clean(formData) }
  })

checkType = <A>(data: A, validate: ValidateFunction<A>): A => {
  validate(data)
  if ((validate.errors ?? undefined) !== undefined) {
    // Taken from doc example: The type cast is needed to allow user-defined keywords and errors
    // You can extend this type to include your error types as needed.

    const errs = validate.errors as DefinedError[]

    for (const err of errs) {
      log.error(err.message)
    }

    log.error(validate.errors)
    log.error(data)

    const errorMessage =
      validate.errors
        ?.map((e) => `${e.instancePath}: ${e.message ?? ''}`)
        .join('\n') ?? 'Unknown error'

    validate.errors?.forEach(console.error)
    throw new Error(`Validation Failed: ${errorMessage}`)
  }

  return data
}

async function jsonToTS(inputFile: string, v: ValidateFunction): Promise<string> {
    const input = await readFile(inputFile, "utf8");
    const data = JSON.parse(input);
    if (!v(data)) {
        console.error(`Validation failed for file ${inputFile}:`);
        console.error(v.errors);
        process.exit(1);
    }
    return (
        "import {TransliterationSchema} from './TransliterationSchema';\n\n" +
        `export default ${JSON.stringify(data)} as TransliterationSchema;`
    );
}

validateUser(user: User) {
		let validate: ValidateFunction;

		switch (user.claim?.type) {
			case UserType.Person:
				validate = this.ajv.getSchema('person');
				break;
			case UserType.Device:
				validate = this.ajv.getSchema('device');
				break;
			case UserType.Organization:
				validate = this.ajv.getSchema('organization');
				break;
			case UserType.Product:
				validate = this.ajv.getSchema('product');
				break;
			case UserType.Service:
				validate = this.ajv.getSchema('service');
				break;
			default:
				break;
		}
		if (!validate) {
			this.logger.log(`no schema found for user type: ${user.claim?.type}`);
			return;
		}

		if (user.claim) {
			const validDetails = <boolean>validate(user.claim);
			if (!validDetails) {
				throw new Error('no valid identity claim');
			}
		}
	}

// Compiles the given schema, and makes sure to also grab any core dependencies
// that it depends on
export function compileAjvSchema(
  schema: Schema,
  options: { disableCache?: boolean } = {},
): ValidateFunction<unknown> {
  const disableCache = options?.disableCache ?? false;
  const cacheKey = disableCache ? '' : JSON.stringify(schema);

  if (!disableCache) {
    const cached = compiledSchemaCache.get(cacheKey);
    if (cached) {
      return cached;
    }
  }

  const extraSchemas = getExtraSchemas(schema);
  const ajv = new Ajv({
    allowUnionTypes: true,
    allErrors: true,
    validateSchema: true,
  });
  if (extraSchemas.length) {
    ajv.addSchema(extraSchemas, undefined, undefined, true);
  }
  const compiled = ajv.compile(schema);

  if (!disableCache) {
    compiledSchemaCache.set(cacheKey, compiled);
  }

  return compiled;
}

export function throwAjvError(
  errors: ValidateFunction<unknown>['errors'],
): never {
  if (!errors?.length) {
    throw new TypeError('Unknown error');
  }

  const error = errors[0];
  throw new TypeError(
    `${error.instancePath || '<root>'} ${error.message}${
      error.params
        ? ` - ${Object.entries(error.params)
            .map(([key, val]) => `${key}: ${val}`)
            .join(', ')}`
        : ''
    }`,
  );
}

async function validateRequestBody(validate: ValidateFunction, body: any) {
  const valid = validate(body);
  const errors = validate.errors && [...validate.errors];

  if (valid === false) {
    throw new ProblemException({
      type: 'invalid-request-body',
      title: 'Invalid Request Body',
      status: 422,
      validationErrors: errors as any,
    });
  }
}

makeActionCreator =
  <A, T extends ActionName>(t: T, validate?: ValidateFunction<A>) =>
  (formData: A) =>
  (year: TaxYear): Save<T, A> => ({
    type: t,
    year,
    formData:
      validate !== undefined
        ? validators.checkType<A>(formData, validate)
        : formData
  })

income1099Int =
  fns.Income1099Int as ValidateFunction<types.Income1099Int>

refund = fns.Refund as ValidateFunction<types.Refund>

estimatedTaxPayments =
  fns.EstimatedTaxPayments as ValidateFunction<types.EstimatedTaxPayments>

taxPayer =
  fns.TaxPayer as ValidateFunction<types.TaxPayerDateString>

information =
  fns.Information as ValidateFunction<types.InformationDateString>

property = fns.Property as ValidateFunction<types.Property>

propertyType =
  fns.PropertyType as ValidateFunction<types.PropertyType>

f1098e = fns.F1098e as ValidateFunction<types.F1098e>

itemizedDeductions =
  fns.ItemizedDeductions as ValidateFunction<types.ItemizedDeductions>

responses = fns.Responses as ValidateFunction<types.Responses>

stateResidency =
  fns.StateResidency as ValidateFunction<types.StateResidency>

healthSavingsAccount =
  fns.HealthSavingsAccount as ValidateFunction<types.HealthSavingsAccountDateString>

ira = fns.Ira as ValidateFunction<types.Ira>

assetType = fns.AssetType as ValidateFunction<types.AssetType>

assetString =
  fns.AssetString as ValidateFunction<types.AssetString>

taxYear = fns.TaxYear as ValidateFunction<types.TaxYear>

credit = fns.Credit as ValidateFunction<types.Credit>

editIraAction =
  fns.EditIRAAction as ValidateFunction<types.EditIraAction>

editHSAAction =
  fns.EditHSAAction as ValidateFunction<types.EditHSAAction>

editCreditAction =
  fns.EditCreditAction as ValidateFunction<types.EditCreditAction>

filingStatus =
  fns.FilingStatus as ValidateFunction<types.FilingStatus>