ipetrovic11 / ts-transformer-json-schema Goto Github PK

View Code? Open in Web Editor NEW

This project forked from kimamula/ts-transformer-keys

13.0 13.0 4.0 266 KB

A TypeScript custom transformer to obtain JSON schema from interface.

License: MIT License

TypeScript 87.73% JavaScript 12.27%

fastest-validator json-schema-generator moleculer transfomer typescript

ts-transformer-json-schema's People

Contributors

Stargazers

Watchers

Forkers

dkuida radojko winton keletes

ts-transformer-json-schema's Issues

Implement Date

Implement Email

Types of arrays

Configuration guidance

I've created this project and I can't seem to get the transform working, I was hoping that you'd be able to take a quick look at it and let me know what I've done wrong please:

https://github.com/Anupheaus/ts-transform-test

Thank you.

Nested interfaces

interface IUser {
    email: string;
    password: string;
}

interface ICompany {
    workspace: string;
}

interface IOnboardRequest {
    user: IUser;
    company: ICompany;
}

Implement UUID

Optional enums generate invalid schema when strict mode enabled

This is a weird one.

An example:

import { schema } from 'ts-transformer-json-schema';

enum MyEnum {
    A = 'A',
    B = 'B'
}

interface IContainsMyEnum {
    enum?: MyEnum;
}

console.log(JSON.stringify(schema<IContainsMyEnum>(), null, 2));

When strict mode is disabled in tsconfig.json (i.e. strict property not set in compilerOptions), the output is as expected:

{
  "enum": {
    "type": "enum",
    "values": [
      "A",
      "B"
    ],
    "optional": true
  }
}

However, when strict mode is enabled (i.e. "strict": "true" in compilerOptions), the output is this:

{
  "enum": [
    {
      "type": "MyEnum.A"
    },
    {
      "type": "MyEnum.B"
    },
    {
      "type": "forbidden"
    }
  ]
}

fastest-validator then complains that MyEnum.A etc. are not valid types, which is correct.

It should be noted that this does not occur with non-optional enums, i.e. they generate the correct enum type in the validation schema.

Enumberables

enum UserGroup {
    Admin = 'admin',
    Manager = 'manager',
    Employee = 'employee'
}

enum UserConfirmationState {
    Pending = 'pending',
    Confirmed = 'confirmed'
}

interface IUserWithGroupsAndState {
    groups: UserGroup[];
    confirmation: UserConfirmationState;
}

Add annotation to exclude property from schema.

Allow specific properties to be excluded from the generated schema.

Handling TS Indexable Types

Currently transformer doesn't solve:
https://www.typescriptlang.org/docs/handbook/interfaces.html#indexable-types

Example:

interface Something { [key: string]: string; }

Change the name of the project to ts-transformer-fastest-validator

I think the name of the project should be changed to ts-transformer-fastest-validator for clarity.

Nested interfaces don't work properly

Having a nested interface e.g.

interface IInner {
  a: string;
}

interface IOuter {
  inner: IInner;
}

Calling schema<IOuter> yields:

{
  inner: { a: { type: "string" } }
}

When it should be (according to https://github.com/icebob/fastest-validator#object):

{
  inner: {
    type: "object",
    props: {
      a: { type: "number" }
   }
}

Nested objects are generated incorrectly.

interface IInner {
  num: number;
  str: string;
}

interface IOuter {
  nested: IInner;
  num: number;
}

Should generate the following output:

{
  num: { type: 'number'},
  nested: {
    type: "object", props: {
      num: { type: 'number'},
      str: { type: 'string'}
    },
}

However it currently generates the following:

{
  type: "object",
  props: {
    num: { type: 'number'}
    nested: {
      num: { type: 'number'},
      str: { type: 'string'}
    },			
  }
}

Validate with the fastest validator how it handles optional union.

Currently:

interface IOptional {
        readonly optional?: string | number;
    }

is resolved into:

{
    type: 'object', props: {
        optional: [{ type: "string" }, { type: "number" }]
    }
}

which actually just ignores ?(question mark - optional).

fastest-validator doesn't have example how that should be handled, there are two options on my mind currently:

{
    type: 'object', props: {
        optional: [{ type: "string" }, { type: "number" },{type: "forbidden"}]
    }
}

{
    type: 'object', props: {
        optional: {
            optional: true, type: [{ type: "string" }, { type: "number" }]
        }
    }
}

Multiple validators

interface IPrimitiveUnion {
    x: number | string;
}

imported types don't work

import type {FooBar} from 'foo-bar';

const schema = schema<FooBar>()

Always returns type any

Optional properties

interface Person {
    name: string;
    age: number;
    phone?: string;
}

Implement Url

Infinite recursion issue

interface IStep1 {
  step2: IStep2;
}

interface IStep2 {
  step1: IStep1;
}

In this case there is infinite recursion which should be stopped.
Proposal for solution:

Once infinite recursion is detected that same element type repeats somewhere in the tree, it should be defined as {type: "any"}