classValidatorToJsonSchema - Get JSON Schema for a specific class

.gitignore

@@ -6,3 +6,4 @@ coverage
 *.key
 *.secret
 yarn-error.log
+.idea

__tests__/classValidatorToJsonSchema.test.ts

@@ -0,0 +1,53 @@
+import { IsString, MinLength } from 'class-validator'
+import { classValidatorToJsonSchema, validationMetadatasToSchemas } from '../src'
+
+export class User {
+  @MinLength(5)
+  @IsString()
+  name: string;
+}
+
+describe('classValidatorToJsonSchema', () => {
+  it('handles default object', async () => {
+    const schema = classValidatorToJsonSchema(User)
+
+    expect(schema).toStrictEqual({
+      properties: {
+        name: { minLength: 5, type: 'string' }
+      },
+      required: ['name'],
+      type: 'object'
+    })
+
+    // Import another User class.
+    const alternativeUserImport = await import('./classes/User')
+
+    /**
+     * By importing another User class with the same name JSON schemas get merged.
+     * User JSON schema now contains properties from the classes/User.ts class as
+     * well (firstName)
+     */
+    const schemas = validationMetadatasToSchemas()
+    expect(Boolean(schemas.User!.properties!.name)).toBeTruthy()
+    expect(Boolean(schemas.User!.properties!.firstName)).toBeTruthy()
+
+    /**
+     * When we get JSON schema for a specific class,
+     * it returns properties specific for that class (without merging)
+     */
+    const schema2 = classValidatorToJsonSchema(User)
+    // Schema stays the same
+    expect(schema).toStrictEqual(schema2)
+
+    const alternativeUserSchema = classValidatorToJsonSchema(alternativeUserImport.User)
+
+    expect(alternativeUserSchema).toStrictEqual({
+      properties: {
+        firstName: { minLength: 5, type: 'string' }
+      },
+      required: ['firstName'],
+      type: 'object'
+    })
+  })
+})
+

__tests__/classes/User.ts

@@ -0,0 +1,7 @@
+import { IsString, MinLength } from 'class-validator'
+
+export class User {
+  @MinLength(5)
+  @IsString()
+  firstName: string;
+}

jest.config.js

@@ -12,7 +12,7 @@ module.exports = {
   moduleDirectories: ['node_modules', 'src'],
   moduleFileExtensions: ['ts', 'js', 'json'],
   roots: ['<rootDir>/__tests__'],
-  testPathIgnorePatterns: ['/node_modules/'],
+  testPathIgnorePatterns: ['/node_modules/', '/__tests__/classes'],
   coverageDirectory: 'coverage',
   collectCoverageFrom: ['src/**/*.{ts,tsx,js,jsx}', '!src/**/*.d.ts']
 }

src/index.ts

@@ -30,29 +30,58 @@ export function validationMetadatasToSchemas(userOptions?: Partial<IOptions>) {
       const target = ownMetas[0].target as Function
       const metas = ownMetas.concat(getInheritedMetadatas(target, metadatas))
 
-      const properties = _(metas)
-        .groupBy('propertyName')
-        .mapValues((propMetas, propKey) => {
-          const schema = applyConverters(propMetas, options)
-          return applyDecorators(schema, target, options, propKey)
-        })
-        .value()
-
-      const definitionSchema: SchemaObject = {
-        properties,
-        type: 'object',
-      }
+      return buildJsonSchemaForSpecificTarget(metadatas, target, metas, options)
+    })
+    .value()
 
-      const required = getRequiredPropNames(target, metas, options)
-      if (required.length > 0) {
-        definitionSchema.required = required
-      }
+  return schemas
+}
 
-      return applyDecorators(definitionSchema, target, options, target.name)
+/**
+ * Convert class-validator class into JSON Schema definition.
+ */
+export type ClassType<T> = new (...args: any[]) => T;
+
+function buildJsonSchemaForSpecificTarget<T>( metadatas: ValidationMetadata[], target: ClassType<T> | Function, targetMetadatas: ValidationMetadata[], options: IOptions) {
+  const metas = targetMetadatas.concat(getInheritedMetadatas(target, metadatas))
+
+  const properties = _(metas)
+    .groupBy('propertyName')
+    .mapValues((propMetas, propKey) => {
+      const schema = applyConverters(propMetas, options)
+      return applyDecorators(schema, target, options, propKey)
     })
     .value()
 
-  return schemas
+  const definitionSchema: SchemaObject = {
+    properties,
+    type: 'object'
+  }
+
+  const required = getRequiredPropNames(target, metas, options)
+  if (required.length > 0) {
+    definitionSchema.required = required
+  }
+
+  return applyDecorators(definitionSchema, target, options, target.name)
+}
+
+export function classValidatorToJsonSchema<T extends object>( target: ClassType<T>, userOptions?: Partial<IOptions>) {
+  const options: IOptions = {
+    ...defaultOptions,
+    ...userOptions,
+  }
+
+  const metadatas = getMetadatasFromStorage(
+    options.classValidatorMetadataStorage
+  )
+
+  const targetMetadatas = _(metadatas)
+    .filter(metadata => {
+      return metadata.target === target
+    }).value();
+
+  return buildJsonSchemaForSpecificTarget(metadatas, target, targetMetadatas, options)
 }
 
 /**