Add JTDDataType to compile signature

lib/core.ts

@@ -30,7 +30,7 @@ export {KeywordCxt} from "./compile/validate"
 export {DefinedError} from "./vocabularies/errors"
 export {JSONType} from "./compile/rules"
 export {JSONSchemaType} from "./types/json-schema"
-export {JTDSchemaType} from "./types/jtd-schema"
+export {JTDSchemaType, SomeJTDSchemaType, JTDDataType} from "./types/jtd-schema"
 export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "./compile/codegen"
 
 import type {
@@ -50,7 +50,7 @@ import type {
   AddedFormat,
 } from "./types"
 import type {JSONSchemaType} from "./types/json-schema"
-import type {JTDSchemaType} from "./types/jtd-schema"
+import type {JTDSchemaType, SomeJTDSchemaType, JTDDataType} from "./types/jtd-schema"
 import ValidationError from "./runtime/validation_error"
 import MissingRefError from "./compile/ref_error"
 import {getRules, ValidationRules, Rule, RuleGroup, JSONType} from "./compile/rules"
@@ -313,6 +313,12 @@ export default class Ajv {
   // Separated for type inference to work
   // eslint-disable-next-line @typescript-eslint/unified-signatures
   validate<T>(schema: JTDSchemaType<T>, data: unknown): data is T
+  // This overload is only intended for typescript inference, the first
+  // argument prevents manual type annotation from matching this overload
+  validate<N extends never, T extends SomeJTDSchemaType>(
+    schema: T,
+    data: unknown
+  ): data is JTDDataType<T>
   validate<T>(schema: AsyncSchema, data: unknown | T): Promise<T>
   validate<T>(schemaKeyRef: AnySchema | string, data: unknown): data is T | Promise<T>
   validate<T>(
@@ -338,6 +344,12 @@ export default class Ajv {
   // Separated for type inference to work
   // eslint-disable-next-line @typescript-eslint/unified-signatures
   compile<T = unknown>(schema: JTDSchemaType<T>, _meta?: boolean): ValidateFunction<T>
+  // This overload is only intended for typescript inference, the first
+  // argument prevents manual type annotation from matching this overload
+  compile<N extends never, T extends SomeJTDSchemaType>(
+    schema: T,
+    _meta?: boolean
+  ): ValidateFunction<JTDDataType<T>>
   compile<T = unknown>(schema: AsyncSchema, _meta?: boolean): AsyncValidateFunction<T>
   compile<T = unknown>(schema: AnySchema, _meta?: boolean): AnyValidateFunction<T>
   compile<T = unknown>(schema: AnySchema, _meta?: boolean): AnyValidateFunction<T> {

lib/jtd.ts

@@ -1,5 +1,5 @@
 import type {AnySchemaObject, SchemaObject, JTDParser} from "./types"
-import type {JTDSchemaType, JTDDataType} from "./types/jtd-schema"
+import type {JTDSchemaType, SomeJTDSchemaType, JTDDataType} from "./types/jtd-schema"
 import AjvCore, {CurrentOptions} from "./core"
 import jtdVocabulary from "./vocabularies/jtd"
 import jtdMetaSchema from "./refs/jtd-schema"
@@ -125,5 +125,5 @@ export {KeywordCxt} from "./compile/validate"
 export {JTDErrorObject} from "./vocabularies/jtd"
 export {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from "./compile/codegen"
 
-export {JTDSchemaType, JTDDataType}
+export {JTDSchemaType, SomeJTDSchemaType, JTDDataType}
 export {JTDOptions}

lib/types/jtd-schema.ts

@@ -1,3 +1,45 @@
+/** numeric strings */
+type NumberType = "float32" | "float64" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32"
+
+/** string strings */
+type StringType = "string" | "timestamp"
+
+/** Generic JTD Schema without inference of the represented type */
+export type SomeJTDSchemaType = (
+  | // ref
+  {ref: string}
+  // primitives
+  | {type: NumberType | StringType | "boolean"}
+  // enum
+  | {enum: string[]}
+  // elements
+  | {elements: SomeJTDSchemaType}
+  // values
+  | {values: SomeJTDSchemaType}
+  // properties
+  | {
+      properties: Record<string, SomeJTDSchemaType>
+      optionalProperties?: Record<string, SomeJTDSchemaType>
+      additionalProperties?: boolean
+    }
+  | {
+      properties?: Record<string, SomeJTDSchemaType>
+      optionalProperties: Record<string, SomeJTDSchemaType>
+      additionalProperties?: boolean
+    }
+  // discriminator
+  | {discriminator: string; mapping: Record<string, SomeJTDSchemaType>}
+  // empty
+  // NOTE see the end of
+  // https://github.com/typescript-eslint/typescript-eslint/issues/2063#issuecomment-675156492
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | {}
+) & {
+  nullable?: boolean
+  metadata?: Record<string, unknown>
+  definitions?: Record<string, SomeJTDSchemaType>
+}
+
 /** required keys of an object, not undefined */
 type RequiredKeys<T> = {
   [K in keyof T]-?: undefined extends T[K] ? never : K
@@ -57,12 +99,6 @@ type IsRecord<T, Union extends boolean> = Union extends IsUnion<Exclude<T, null>
     : true
   : false
 
-/** numeric strings */
-type NumberType = "float32" | "float64" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32"
-
-/** string strings */
-type StringType = "string" | "timestamp"
-
 /** actual schema */
 export type JTDSchemaType<T, D extends Record<string, unknown> = Record<string, never>> = (
   | // refs - where null wasn't specified, must match exactly
@@ -164,7 +200,9 @@ export type JTDSchemaType<T, D extends Record<string, unknown> = Record<string,
 type JTDDataDef<S, D extends Record<string, unknown>> =
   | (// ref
     S extends {ref: string}
-      ? JTDDataDef<D[S["ref"]], D>
+      ? D extends {[K in S["ref"]]: infer V}
+        ? JTDDataDef<V, D>
+        : never
       : // type
       S extends {type: NumberType}
       ? number

spec/types/jtd-schema.spec.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-empty-interface,no-void */
 import _Ajv from "../ajv_jtd"
-import type {JTDSchemaType, JTDDataType} from "../../dist/jtd"
+import type {JTDSchemaType, SomeJTDSchemaType, JTDDataType} from "../../dist/jtd"
 import chai from "../chai"
 const should = chai.should()
 
@@ -353,16 +353,14 @@ describe("JTDDataType", () => {
       },
     } as const
 
-    type MyData1 = JTDDataType<typeof mySchema1>
-
-    const validate = ajv.compile<MyData1>(mySchema1)
+    const validate = ajv.compile(mySchema1)
     const validData: unknown = {type: "a", a: 1}
     if (validate(validData) && validData.type === "a") {
       validData.a.should.equal(1)
     }
     should.not.exist(validate.errors)
 
-    if (ajv.validate<MyData1>(mySchema1, validData) && validData.type === "a") {
+    if (ajv.validate(mySchema1, validData) && validData.type === "a") {
       validData.a.should.equal(1)
     }
     should.not.exist(ajv.errors)
@@ -492,3 +490,13 @@ describe("JTDDataType", () => {
     void [empty]
   })
 })
+
+describe("SomeJTDSchemaType", () => {
+  it("should allow setting unknowns", () => {
+    // This test is basically here to assert that we should be using `{}` in
+    // SomeJTDSchemaType
+    const schema: SomeJTDSchemaType = {}
+
+    void [schema]
+  })
+})