nodenext compatibility (#90)

* move types to types folder

* nodenext compatibility

* initial

* EOD

* Apply suggestions from code review

Co-authored-by: Manuel Spigolon <[email protected]>

Co-authored-by: Manuel Spigolon <[email protected]>

Author: Uzlopak

index.d.ts

@@ -4,7 +4,7 @@ const AjvReference = Symbol.for('fastify.ajv-compiler.reference')
 const ValidatorCompiler = require('./lib/validator-compiler')
 const SerializerCompiler = require('./lib/serializer-compiler')
 
-function ValidatorSelector (opts) {
+function AjvCompiler (opts) {
   const validatorPool = new Map()
   const serializerPool = new Map()
 
@@ -46,6 +46,8 @@ function getPoolKey (externalSchemas, options) {
   const ajvConfig = JSON.stringify(options)
   return `${externals}${ajvConfig}`
 }
-module.exports = ValidatorSelector
+module.exports = AjvCompiler
+module.exports.default = AjvCompiler
+module.exports.AjvCompiler = AjvCompiler
 module.exports.AjvReference = AjvReference
 module.exports.StandaloneValidator = require('./standalone')

index.js

@@ -3,7 +3,7 @@
   "version": "3.4.0",
   "description": "Build and manage the AJV instances for the fastify framework",
   "main": "index.js",
-  "types": "index.d.ts",
+  "types": "types/index.d.ts",
   "directories": {
     "test": "test"
   },
@@ -51,8 +51,5 @@
     "ajv": "^8.11.0",
     "ajv-formats": "^2.1.1",
     "fast-uri": "^2.0.0"
-  },
-  "tsd": {
-    "directory": "test/types"
   }
 }

package.json

@@ -0,0 +1,72 @@
+import { AnySchema,  default as _ajv, Options as AjvOptions, ValidateFunction } from "ajv";
+import { default as AjvJTD, JTDOptions } from "ajv/dist/jtd";
+import type { Options, ErrorObject } from "ajv";
+import { AnyValidateFunction } from "ajv/dist/core";
+
+type Ajv = _ajv;
+type AjvSerializerGenerator = typeof AjvCompiler
+
+type AjvJTDCompile = AjvJTD['compileSerializer']
+type AjvCompile = (schema: AnySchema, _meta?: boolean) => AnyValidateFunction
+
+declare namespace AjvCompiler {
+  export type { Options, ErrorObject }
+  export { Ajv };
+
+  export type BuildSerializerFromPool = typeof buildSerializerFromPool
+
+  export type BuildCompilerFromPool = typeof buildCompilerFromPool
+
+  export const AjvReference: Symbol
+
+  export enum HttpParts {
+    Body = "body",
+    Headers = "headers",
+    Params = "params",
+    Query = "querystring",
+  }
+
+  export type RouteDefinition = {
+    method: string,
+    url: string,
+    httpPart: HttpParts,
+    schema?: unknown,
+  }
+
+  export type StandaloneRestoreFunction = (opts: RouteDefinition) => ValidateFunction
+
+  export type StandaloneStoreFunction = (opts: RouteDefinition, schemaValidationCode: string) => void
+
+  export type StandaloneOptionsReadModeOn = {
+    readMode: true;
+    restoreFunction?: StandaloneRestoreFunction
+  }
+
+  export type StandaloneOptionsReadModeOff = {
+    readMode?: false | undefined;
+    storeFunction?: StandaloneStoreFunction;
+  }
+
+  export type StandaloneOptions = StandaloneOptionsReadModeOn | StandaloneOptionsReadModeOff
+
+  export type ValidatorFactory = BuildCompilerFromPool | BuildSerializerFromPool
+
+  export type ValidatorCompiler = ReturnType<ValidatorFactory>
+
+  export { StandaloneValidator }
+
+  export const AjvCompiler: AjvSerializerGenerator
+  export { AjvCompiler as default }
+}
+
+declare function buildCompilerFromPool(externalSchemas: { [key: string]: AnySchema | AnySchema[] }, options?: { mode: 'JTD'; customOptions?: JTDOptions }): AjvCompile
+declare function buildCompilerFromPool(externalSchemas: { [key: string]: AnySchema | AnySchema[] }, options?: { mode?: never; customOptions?: AjvOptions }): AjvCompile
+
+declare function buildSerializerFromPool(externalSchemas: any, serializerOpts?: { mode?: never; } & JTDOptions): AjvJTDCompile
+
+declare function AjvCompiler(opts: { jtdSerializer: true }): AjvCompiler.BuildSerializerFromPool
+declare function AjvCompiler(opts?: { jtdSerializer?: false }): AjvCompiler.BuildCompilerFromPool
+
+declare function StandaloneValidator(options: AjvCompiler.StandaloneOptions): AjvCompiler.BuildCompilerFromPool;
+
+export = AjvCompiler

test/types/index.test.ts

@@ -0,0 +1,216 @@
+import { AnySchemaObject, ValidateFunction } from "ajv";
+import { AnyValidateFunction } from "ajv/dist/core";
+import { expectAssignable, expectType } from "tsd";
+import AjvCompiler, { AjvReference, ValidatorFactory, StandaloneValidator, RouteDefinition, ErrorObject, BuildCompilerFromPool, BuildSerializerFromPool, ValidatorCompiler } from "..";
+
+{
+  const compiler = AjvCompiler({});
+  expectType<BuildCompilerFromPool>(compiler);
+}
+{
+  const compiler = AjvCompiler();
+  expectType<BuildCompilerFromPool>(compiler);
+}
+{
+  const compiler = AjvCompiler({ jtdSerializer: false});
+  expectType<BuildCompilerFromPool>(compiler);
+}
+{
+  const compiler = AjvCompiler({ jtdSerializer: true});
+  expectType<BuildSerializerFromPool>(compiler);
+}
+const reader = StandaloneValidator({
+  readMode: true,
+  restoreFunction: (route: RouteDefinition) => {
+    expectAssignable<RouteDefinition>(route)
+    return {} as ValidateFunction
+  },
+});
+expectAssignable<ValidatorFactory>(reader);
+
+const writer = StandaloneValidator({
+  readMode: false,
+  storeFunction: (route: RouteDefinition, code: string) => {
+    expectAssignable<RouteDefinition>(route)
+    expectAssignable<string>(code)
+  },
+});
+expectAssignable<ValidatorFactory>(writer);
+
+expectType<unknown>(({} as ErrorObject).data)
+expectType<string>(({} as ErrorObject).instancePath)
+expectType<string>(({} as ErrorObject).keyword)
+expectType<string | undefined>(({} as ErrorObject).message)
+expectType<Record<string, any>>(({} as ErrorObject).params)
+expectType<AnySchemaObject | undefined>(({} as ErrorObject).parentSchema)
+expectType<string | undefined>(({} as ErrorObject).propertyName)
+expectType<unknown>(({} as ErrorObject).schema)
+expectType<string>(({} as ErrorObject).schemaPath)
+
+expectType<Symbol>(AjvReference)
+
+{
+  const jtdSchema = {
+    discriminator: 'version',
+    mapping: {
+      1: {
+        properties: {
+          foo: { type: 'uint8' }
+        }
+      },
+      2: {
+        properties: {
+          foo: { type: 'string' }
+        }
+      }
+    }
+  }
+
+  const externalSchemas1 = {
+    foo: {
+      definitions: {
+        coordinates: {
+          properties: {
+            lat: { type: 'float32' },
+            lng: { type: 'float32' }
+          }
+        }
+      }
+    }
+  }
+
+  const factory = AjvCompiler({ jtdSerializer: true })
+  expectType<BuildSerializerFromPool>(factory)
+  const compiler = factory(externalSchemas1, {})
+  expectAssignable<Function>(compiler)
+  const serializeFunc = compiler({ schema: jtdSchema })
+  expectType<(data: unknown) => string>(serializeFunc)
+  expectType<string>(serializeFunc({ version: '1', foo: 42 }))
+}
+// JTD
+{
+
+  const factory = AjvCompiler()
+  expectType<BuildCompilerFromPool>(factory)
+
+  const jtdSchema = {
+    discriminator: 'version',
+    mapping: {
+      1: {
+        properties: {
+          foo: { type: 'uint8' }
+        }
+      },
+      2: {
+        properties: {
+          foo: { type: 'string' }
+        }
+      }
+    }
+  }
+
+  const compiler = factory({}, {
+    customOptions: {},
+    mode: 'JTD'
+  })
+  expectAssignable<ValidatorCompiler>(compiler)
+  const validatorFunc = compiler({ schema: jtdSchema })
+  expectAssignable<ValidateFunction>(validatorFunc)
+
+  expectType<boolean | Promise<any>>(validatorFunc({
+    version: '2',
+    foo: []
+  }))
+}
+
+// generate standalone code
+{
+  const base = {
+    $id: 'urn:schema:base',
+    definitions: {
+      hello: { type: 'string' }
+    },
+    type: 'object',
+    properties: {
+      hello: { $ref: '#/definitions/hello' }
+    }
+  }
+
+  const refSchema = {
+    $id: 'urn:schema:ref',
+    type: 'object',
+    properties: {
+      hello: { $ref: 'urn:schema:base#/definitions/hello' }
+    }
+  }
+
+  const endpointSchema = {
+    schema: {
+      $id: 'urn:schema:endpoint',
+      $ref: 'urn:schema:ref'
+    }
+  }
+
+  const schemaMap = {
+    [base.$id]: base,
+    [refSchema.$id]: refSchema
+  }
+
+  const factory = StandaloneValidator({
+    readMode: false,
+    storeFunction(routeOpts, schemaValidationCode) {
+      expectType<RouteDefinition>(routeOpts)
+      expectType<string>(schemaValidationCode)
+    }
+  })
+  expectAssignable<ValidatorFactory>(factory)
+
+  const compiler = factory(schemaMap)
+  expectAssignable<ValidatorCompiler>(compiler)
+  expectAssignable<Function>(compiler(endpointSchema))
+}
+
+{
+  const base = {
+    $id: 'urn:schema:base',
+    definitions: {
+      hello: { type: 'string' }
+    },
+    type: 'object',
+    properties: {
+      hello: { $ref: '#/definitions/hello' }
+    }
+  }
+
+  const refSchema = {
+    $id: 'urn:schema:ref',
+    type: 'object',
+    properties: {
+      hello: { $ref: 'urn:schema:base#/definitions/hello' }
+    }
+  }
+
+  const endpointSchema = {
+    schema: {
+      $id: 'urn:schema:endpoint',
+      $ref: 'urn:schema:ref'
+    }
+  }
+
+  const schemaMap = {
+    [base.$id]: base,
+    [refSchema.$id]: refSchema
+  }
+  const factory = StandaloneValidator({
+    readMode: true,
+    restoreFunction(routeOpts) {
+      expectType<RouteDefinition>(routeOpts)
+      return {} as ValidateFunction
+    }
+  })
+  expectAssignable<ValidatorFactory>(factory)
+
+  const compiler = factory(schemaMap)
+  expectAssignable<ValidatorCompiler>(compiler)
+  expectType<AnyValidateFunction<any>>(compiler(endpointSchema))
+}