const ajv = new Ajv({ coerceTypes: "array" });
const schema = {
  properties: {
    foo: { type: "array", items: { type: "number" } },
    bar: { type: "boolean" },
  },
};

const data = { foo: "1", bar: ["false"] };

const validate = ajv.compile(schema);

console.log(validate(data)); // true
console.log(data); // { "foo": [1], "bar": false }

const ajv = new Ajv({ processCode: transpileFunc });
const validate = ajv.compile(schema); // transpiled es7 async function
validate(data).then(successFunc).catch(errorFunc);

const ajv = new Ajv();
const validate = ajv.addSchema(defsSchema).compile(schema);

const ajv = new Ajv()

ajv.addKeyword({
  keyword: "idExists"
  async: true,
  type: "number",
  validate: checkIdExists,
})

async function checkIdExists(schema, data) {
  // this is just an example, you would want to avoid SQL injection in your code
  const rows = await sql(`SELECT id FROM ${schema.table} WHERE id = ${data}`)
  return !!rows.length // true if record is found
}

const schema = {
  $async: true,
  properties: {
    userId: {
      type: "integer",
      idExists: {table: "users"},
    },
    postId: {
      type: "integer",
      idExists: {table: "posts"},
    },
  },
}

const validate = ajv.compile(schema)

validate({userId: 1, postId: 19})
  .then(function (data) {
    console.log("Data is valid", data) // { userId: 1, postId: 19 }
  })
  .catch(function (err) {
    if (!(err instanceof Ajv.ValidationError)) throw err
    // data is invalid
    console.log("Validation errors:", err.errors)
  })

const ajv = new Ajv({ removeAdditional: true });
const schema = {
  additionalProperties: false,
  properties: {
    foo: { type: "number" },
    bar: {
      additionalProperties: { type: "number" },
      properties: {
        baz: { type: "string" },
      },
    },
  },
};

const data = {
  foo: 0,
  additional1: 1, // will be removed; `additionalProperties` == false
  bar: {
    baz: "abc",
    additional2: 2, // will NOT be removed; `additionalProperties` != false
  },
};

const validate = ajv.compile(schema);

console.log(validate(data)); // true
console.log(data); // { "foo": 0, "bar": { "baz": "abc", "additional2": 2 }

const ajv = new Ajv({ useDefaults: true });
const schema = {
  type: "object",
  properties: {
    foo: { type: "number" },
    bar: { type: "string", default: "baz" },
  },
  required: ["foo", "bar"],
};

const data = { foo: 1 };

const validate = ajv.compile(schema);

console.log(validate(data)); // true
console.log(data); // { "foo": 1, "bar": "baz" }

const Ajv = require("ajv");
const ajv = new Ajv(); // options can be passed, e.g. {allErrors: true}

const schema = {
  type: "object",
  properties: {
    foo: { type: "integer" },
    bar: { type: "string" },
  },
  required: ["foo"],
  additionalProperties: false,
};

const validate = ajv.compile(schema);

const data = {
  foo: 1,
  bar: "abc",
};

const valid = validate(data);
if (!valid) console.log(validate.errors);

const Ajv = require("ajv").default;
const schema_user = require("./schema_user.json");
const ajv = new Ajv();
const validate_user = ajv.compile(schema_user);

// this is just some abstract API framework
app.post("/user", async (cxt) => {
  if (validate_user(cxt.body)) {
    // create user
  } else {
    // report error
    cxt.status(400);
  }
});

    validateConfiguration(configuration) {
        const validate = ajv.compile(schema);
        const valid = validate(configuration);
        return {
            valid,
            errorsText: valid ? null : betterAjvErrors(schema, configuration, validate.errors),
        };
    }

import Ajv from "ajv";
import * as schema_user from "./schema_user.json";
const ajv = new Ajv();
const validate_user = ajv.compile(schema_user);

interface User {
  username: string;
}

// this is just some abstract API framework
app.post("/user", async (cxt) => {
  if (validate_user(cxt.body)) {
    // create user
  } else {
    // report error
    cxt.status(400);
  }
});

const ajv = new Ajv();
const validate = ajv.compile(schema);
if (validate(data)) {
  // data is MyData here
  // ...
} else {
  // DefinedError is a type for all pre-defined keywords errors,
  // validate.errors has type ErrorObject[] - to allow user-defined keywords with any error parameters.
  // Users can extend DefinedError to include the keywords errors they defined.
  for (const err of validate.errors as DefinedError[]) {
    switch (err.keyword) {
      case "maximum":
        console.log(err.limit);
        break;
      case "pattern":
        console.log(err.pattern);
        break;
      // ...
    }
  }
}

const ajv = new Ajv({ coerceTypes: true });
const schema = {
  type: "object",
  properties: {
    foo: { type: "number" },
    bar: { type: "boolean" },
  },
  required: ["foo", "bar"],
};

const data = { foo: "1", bar: "false" };

const validate = ajv.compile(schema);

console.log(validate(data)); // true
console.log(data); // { "foo": 1, "bar": false }

const Ajv = require("ajv"); // version >= v7.0.0
const ajv = new Ajv({ code: { source: true } }); // this option is required to generate standalone code
const standaloneCode = require("ajv/dist/standalone");

const schema = {
  $id: "https://example.com/object.json",
  type: "object",
  properties: {
    foo: {
      type: "string",
      pattern: "^[a-z]+$",
    },
  },
};

// 1. generate module with a single default export (CommonJS and ESM compatible):
const validate = ajv.compile(schema);
let moduleCode = standaloneCode(ajv, validate);

// 2. pass map of schema IDs to generate multiple exports,
// it avoids code duplication if schemas are mutually recursive or have some share elements:
let moduleCode = standaloneCode(ajv, {
  validateObject: "https://example.com/object.json",
});

// 3. or generate module with all schemas added to the instance (excluding meta-schemas),
// export names would use schema IDs (or keys passed to addSchema method):
let moduleCode = standaloneCode(ajv);

// now you can
// write module code to file
const fs = require("fs");
const path = require("path");
fs.writeFileSync(
  path.join(__dirname, "/validate.js"),
  moduleCode
);

// ... or require module from string
const requireFromString = require("require-from-string");
const standaloneValidate = requireFromString(moduleCode); // for a single default export

import Ajv, { JSONSchemaType } from "ajv";
const ajv = new Ajv();

interface MyData {
  foo: number;
  bar?: string;
}

const schema: JSONSchemaType = {
  type: "object",
  properties: {
    foo: { type: "integer" },
    bar: { type: "string", nullable: true },
  },
  required: ["foo"],
  additionalProperties: false,
};

// validate is a type guard for MyData - type is inferred from schema type
const validate = ajv.compile(schema);

// or, if you did not use type annotation for the schema,
// type parameter can be used to make it type guard:
// const validate = ajv.compile(schema)

const data = {
  foo: 1,
  bar: "abc",
};

if (validate(data)) {
  // data is MyData here
  console.log(data.foo);
} else {
  console.log(validate.errors);
}

const Ajv = require("ajv").default;
const schema_user = require("./schema_user.json");
const ajv = new Ajv();
const validate_user = ajv.compile(schema_user);

// this is just some abstract API framework
app.post("/user", async (cxt) => {
  if (validate_user(cxt.body)) {
    // create user
  } else {
    // report error
    cxt.status(400);
  }
});

const ajv = new Ajv({ processCode: transpileFunc });
const validate = ajv.compile(schema); // transpiled es7 async function
validate(data).then(successFunc).catch(errorFunc);

const ajv = new Ajv()

ajv.addKeyword({
  keyword: "idExists"
  async: true,
  type: "number",
  validate: checkIdExists,
})

async function checkIdExists(schema, data) {
  // this is just an example, you would want to avoid SQL injection in your code
  const rows = await sql(`SELECT id FROM ${schema.table} WHERE id = ${data}`)
  return !!rows.length // true if record is found
}

const schema = {
  $async: true,
  properties: {
    userId: {
      type: "integer",
      idExists: {table: "users"},
    },
    postId: {
      type: "integer",
      idExists: {table: "posts"},
    },
  },
}

const validate = ajv.compile(schema)

validate({userId: 1, postId: 19})
  .then(function (data) {
    console.log("Data is valid", data) // { userId: 1, postId: 19 }
  })
  .catch(function (err) {
    if (!(err instanceof Ajv.ValidationError)) throw err
    // data is invalid
    console.log("Validation errors:", err.errors)
  })

const schema = {
  type: "object",
  required: ["foo"],
  properties: {
    foo: { type: "integer" },
  },
  additionalProperties: false,
  errorMessage: {
    type: "should be an object", // will not replace internal "type" error for the property "foo"
    required: "should have property foo",
    additionalProperties:
      "should not have properties other than foo",
  },
};

const validate = ajv.compile(schema);
console.log(validate({ foo: "a", bar: 2 })); // false
console.log(validate.errors); // processed errors

const schema = {
  type: "object",
  required: ["foo"],
  properties: {
    foo: { type: "integer" },
  },
  additionalProperties: false,
  errorMessage:
    "should be an object with an integer property foo only",
};

const validate = ajv.compile(schema);
console.log(validate({ foo: "a", bar: 2 })); // false
console.log(validate.errors); // processed errors

const schema = {
  type: "object",
  required: ["foo", "bar"],
  allOf: [
    {
      properties: {
        foo: { type: "integer", minimum: 2 },
        bar: { type: "string", minLength: 2 },
      },
      additionalProperties: false,
    },
  ],
  errorMessage: {
    properties: {
      foo: "data.foo should be integer >= 2",
      bar: "data.bar should be string with length >= 2",
    },
  },
};

const validate = ajv.compile(schema);
console.log(validate({ foo: 1, bar: "a" })); // false
console.log(validate.errors); // processed errors

const schema = {
  type: "object",
  required: ["foo", "bar"],
  allOf: [
    {
      properties: {
        foo: { type: "integer", minimum: 2 },
        bar: { type: "string", minLength: 2 },
      },
      additionalProperties: false,
    },
  ],
  errorMessage: {
    type: "data should be an object",
    properties: {
      foo: "data.foo should be integer >= 2",
      bar: "data.bar should be string with length >= 2",
    },
    _: 'data should have properties "foo" and "bar" only',
  },
};

const validate = ajv.compile(schema);
console.log(validate({})); // false
console.log(validate.errors); // processed errors

const ajv = new Ajv({ loadSchema: loadSchema });

ajv.compileAsync(schema).then(function (validate) {
  const valid = validate(data);
  // ...
});

async function loadSchema(uri) {
  const res = await request.json(uri);
  if (res.statusCode >= 400)
    throw new Error("Loading error: " + res.statusCode);
  return res.body;
}