Javascript – how to pre compile AJV standalone validation code when you have custom keywords?

Unfortunately, the validate function alone cannot be directly used for generating precompiled standalone code with AJV. This is because AJV requires custom keywords to define their behavior in terms of JavaScript code generation when creating standalone precompiled validators. The validate function is executed at runtime, while the code property is used during the compilation process to generate code.

1. Is there a way to use the validate property for precompiled standalone code?

No, AJV’s standalone generation mechanism requires the code property to define how the keyword translates to JavaScript code. The validate function cannot be directly used for this purpose.

2. How to convert the validate function into code for standalone generation?

To translate your validate function into a code generator function, you can:

• Break down the logic of your validate function into reusable components.
• Use the KeywordCxt object provided by AJV’s code property to inject equivalent logic during code generation.

Here’s an example of how you might achieve this:

Your Current Validate Function

validate: (schema, data) => {
  try {
    const unique_name = data.map((tar) => {
      return tar.name.toLowerCase().replaceAll(/s+/g, "");
    });
    const unique_id = data.map((tar) => {
      return tar._id;
    });
    return (
      new Set(unique_name).size === data.length &&
      new Set(unique_id).size === data.length
    );
  } catch (err) {
    return false;
  }
},

Converted Code Generator Function

Here’s a translation of this into the code generator:

const {_, str} = require("ajv/dist/compile/codegen");

ajv_inst.addKeyword({
  keyword: "custom_array",
  type: "array",
  schemaType: "boolean", // Expecting a boolean schema
  code(cxt) {
    const {data} = cxt; // The JSON data being validated

    // Generate a function to create unique name and ID arrays
    const uniqueNameCode = _`(${data}.map(tar => tar.name.toLowerCase().replace(/\s+/g, "")))`;
    const uniqueIdCode = _`(${data}.map(tar => tar._id))`;

    // Validate that the sets have the same length as the original array
    cxt.fail(
      _`new Set(${uniqueNameCode}).size !== ${data}.length || new Set(${uniqueIdCode}).size !== ${data}.length`
    );
  },
  metaSchema: { enum: [true] }, // The schema for the keyword itself
});

Explanation

• KeywordCxt: The cxt object provides methods and properties to manipulate validation logic dynamically during code generation.
• _ Syntax: The codegen utility _ is used to create JavaScript code expressions.
• Inject Logic: We use cxt.fail to indicate a validation failure when the unique name or unique ID conditions are not met.

Benefits of Using code for Standalone

• The generated validator will include your custom keyword logic directly in the compiled output.

• This approach avoids runtime dependencies and ensures efficient execution.

Automating Conversion

While there isn’t a direct tool to automate the conversion from a validate function to a code function, you can:

• Use static analysis to identify your function’s dependencies and logic.
• Write a helper function that dynamically maps runtime logic to compile-time expressions.

For simple keywords, the conversion is often straightforward. However, for complex logic, it may require manual adjustments as seen above.