Add overloaded signatures for sync/async compile

lib/ajv.ts

@@ -1,10 +1,14 @@
 import {
   Schema,
   SchemaObject,
+  SyncSchemaObject,
+  AsyncSchemaObject,
   Vocabulary,
   KeywordDefinition,
   Options,
   ValidateFunction,
+  SyncValidateFunction,
+  AsyncValidateFunction,
   CacheInterface,
   Logger,
   ErrorObject,
@@ -107,6 +111,10 @@ export default class Ajv {
   }
 
   // Create validation function for passed schema
+  compile(s: {$async?: never}, _?: boolean): ValidateFunction
+  compile(s: SyncSchemaObject, _?: boolean): SyncValidateFunction
+  compile(s: AsyncSchemaObject, _?: boolean): AsyncValidateFunction
+  compile(s: Schema, _?: boolean): ValidateFunction
   compile(
     schema: Schema,
     _meta?: boolean // true if schema is a meta-schema. Used internally to compile meta schemas of custom keywords.
@@ -117,6 +125,26 @@ export default class Ajv {
 
   // Creates validating function for passed schema with asynchronous loading of missing schemas.
   // `loadSchema` option should be a function that accepts schema uri and returns promise that resolves with the schema.
+  compileAsync(
+    s: {$async?: never},
+    m?: boolean | CompileAsyncCallback,
+    c?: CompileAsyncCallback
+  ): Promise<ValidateFunction>
+  compileAsync(
+    s: SyncSchemaObject,
+    m?: boolean | CompileAsyncCallback,
+    c?: CompileAsyncCallback
+  ): Promise<SyncValidateFunction>
+  compileAsync(
+    s: AsyncSchemaObject,
+    m?: boolean | CompileAsyncCallback,
+    c?: CompileAsyncCallback
+  ): Promise<AsyncValidateFunction>
+  compileAsync(
+    s: SchemaObject,
+    m?: boolean | CompileAsyncCallback,
+    c?: CompileAsyncCallback
+  ): Promise<ValidateFunction>
   compileAsync(
     schema: SchemaObject,
     metaOrCallback?: boolean | CompileAsyncCallback, // optional true to compile meta-schema; this parameter can be skipped

lib/types.ts

@@ -106,6 +106,10 @@ export interface ValidateFunction {
   source?: SourceCode
 }
 
+export interface SyncSchemaObject extends SchemaObject {
+  $async: false
+}
+
 export interface SyncValidateFunction extends ValidateFunction {
   (
     this: Ajv | any,
@@ -118,6 +122,10 @@ export interface SyncValidateFunction extends ValidateFunction {
   $async: undefined
 }
 
+export interface AsyncSchemaObject extends SchemaObject {
+  $async: true
+}
+
 export interface AsyncValidateFunction extends ValidateFunction {
   (
     this: Ajv | any,

spec/options/async.spec.ts

@@ -0,0 +1,73 @@
+import _Ajv from "../ajv"
+require("../chai").should()
+
+describe("$async option", () => {
+  const ajv = new _Ajv()
+
+  describe("= undefined", () => {
+    const validate = ajv.compile({})
+    it("should return a boolean or promise", async () => {
+      const result = validate({})
+      if (typeof result === "boolean") {
+        result.should.exist
+      } else {
+        await result.then((data) => data.should.exist)
+      }
+    })
+  })
+
+  describe("= false", () => {
+    const validate = ajv.compile({$async: false})
+    it("should return a boolean", () => {
+      const result: boolean = validate({})
+      result.should.exist
+    })
+  })
+
+  describe("= true", () => {
+    const validate = ajv.compile({$async: true})
+    it("should return a promise", async () => {
+      const result: Promise<any> = validate({})
+      await result.then((data) => data.should.exist)
+    })
+  })
+
+  describe("= boolean", () => {
+    const schema = {$async: true}
+    const validate = ajv.compile(schema)
+    it("should return boolean or promise", async () => {
+      const result = validate({})
+      if (typeof result === "boolean") {
+        result.should.exist
+      } else {
+        await result.then((data) => data.should.exist)
+      }
+    })
+  })
+
+  describe("of type unknown", () => {
+    const schema: Record<string, unknown> = {}
+    const validate = ajv.compile(schema)
+    it("should return boolean or promise", async () => {
+      const result = validate({})
+      if (typeof result === "boolean") {
+        result.should.exist
+      } else {
+        await result.then((data) => data.should.exist)
+      }
+    })
+  })
+
+  describe("of type any", () => {
+    const schema: any = {}
+    const validate = ajv.compile(schema)
+    it("should return boolean or promise", async () => {
+      const result = validate({})
+      if (typeof result === "boolean") {
+        result.should.exist
+      } else {
+        await result.then((data) => data.should.exist)
+      }
+    })
+  })
+})