ts json schema generator
v2.3.0
Versão estendida de https://github.com/xiag-ag/typescript-to-json-schema.
Inspirado em YousefED/typescript-json-schema . Aqui está a lista de diferenças:
typeChecker.getTypeAtLocation() (então provavelmente mantém aliases de tipo corretos)definitions no esquema JSON Este projeto é possível graças a uma comunidade de colaboradores. Aceitamos contribuições de qualquer tipo (problemas, código, documentação, exemplos, testes,...). Por favor, leia nosso código de conduta.
Execute o gerador de esquema com npx:
npx ts-json-schema-generator --path ' my/project/**/*.ts ' --type ' My.Type.Name 'Ou instale o pacote e execute-o
npm install --save ts-json-schema-generator
./node_modules/.bin/ts-json-schema-generator --path ' my/project/**/*.ts ' --type ' My.Type.Name 'Observe que plataformas diferentes (por exemplo, Windows) podem usar separadores de caminho diferentes, portanto talvez seja necessário ajustar o comando acima.
Observe também que você precisa citar os caminhos com * , caso contrário o shell expandirá os caminhos e, portanto, passará apenas o primeiro caminho para o gerador.
Por padrão, o gerador de linha de comando usará o arquivo tsconfig.json no diretório de trabalho atual ou o primeiro diretório pai que contém um arquivo tsconfig.json até a raiz do sistema de arquivos. Se quiser usar um arquivo tsconfig.json diferente, você pode usar a opção --tsconfig . Em particular, se você precisar usar diferentes opções de compilação para tipos, talvez queira criar um arquivo tsconfig.json separado apenas para a geração do esquema.
-p, --path <path> Source file path
-t, --type <name> Type name
-i, --id <name> $id for generated schema
-f, --tsconfig <path> Custom tsconfig.json path
-e, --expose <expose> Type exposing (choices: "all", "none", "export", default: "export")
-j, --jsDoc <extended> Read JsDoc annotations (choices: "none", "basic", "extended", default: "extended")
--markdown-description Generate `markdownDescription` in addition to `description`.
--functions <functions> How to handle functions. `fail` will throw an error. `comment` will add a comment. `hide` will treat the function like a NeverType or HiddenType.
(choices: "fail", "comment", "hide", default: "comment")
--minify Minify generated schema (default: false)
--unstable Do not sort properties
--strict-tuples Do not allow additional items on tuples
--no-top-ref Do not create a top-level $ref definition
--no-type-check Skip type checks to improve performance
--no-ref-encode Do not encode references
-o, --out <file> Set the output file (default: stdout)
--validation-keywords [value] Provide additional validation keywords to include (default: [])
--additional-properties Allow additional properties for objects with no index signature (default: false)
-V, --version output the version number
-h, --help display help for command
// main.js
const tsj = require ( "ts-json-schema-generator" ) ;
const fs = require ( "fs" ) ;
/** @type {import('ts-json-schema-generator/dist/src/Config').Config} */
const config = {
path : "path/to/source/file" ,
tsconfig : "path/to/tsconfig.json" ,
type : "*" , // Or <type-name> if you want to generate schema for that one type only
} ;
const outputPath = "path/to/output/file" ;
const schema = tsj . createGenerator ( config ) . createSchema ( config . type ) ;
const schemaString = JSON . stringify ( schema , null , 2 ) ;
fs . writeFile ( outputPath , schemaString , ( err ) => {
if ( err ) throw err ;
} ) ; Execute o gerador de esquema por meio node main.js .
Estender a formatação integrada é possível criando um formatador personalizado e adicionando-o ao formatador principal:
// my-function-formatter.ts
import { BaseType , Definition , FunctionType , SubTypeFormatter } from "ts-json-schema-generator" ;
import ts from "typescript" ;
export class MyFunctionTypeFormatter implements SubTypeFormatter {
// You can skip this line if you don't need childTypeFormatter
public constructor ( private childTypeFormatter : TypeFormatter ) { }
public supportsType ( type : BaseType ) : boolean {
return type instanceof FunctionType ;
}
public getDefinition ( type : FunctionType ) : Definition {
// Return a custom schema for the function property.
return {
type : "object" ,
properties : {
isFunction : {
type : "boolean" ,
const : true ,
} ,
} ,
} ;
}
// If this type does NOT HAVE children, generally all you need is:
public getChildren ( type : FunctionType ) : BaseType [ ] {
return [ ] ;
}
// However, if children ARE supported, you'll need something similar to
// this (see src/TypeFormatter/{Array,Definition,etc}.ts for some examples):
public getChildren ( type : FunctionType ) : BaseType [ ] {
return this . childTypeFormatter . getChildren ( type . getType ( ) ) ;
}
} import { createProgram , createParser , SchemaGenerator , createFormatter } from "ts-json-schema-generator" ;
import { MyFunctionTypeFormatter } from "./my-function-formatter.ts" ;
import fs from "fs" ;
const config = {
path : "path/to/source/file" ,
tsconfig : "path/to/tsconfig.json" ,
type : "*" , // Or <type-name> if you want to generate schema for that one type only
} ;
// We configure the formatter an add our custom formatter to it.
const formatter = createFormatter ( config , ( fmt , circularReferenceTypeFormatter ) => {
// If your formatter DOES NOT support children, e.g. getChildren() { return [] }:
fmt . addTypeFormatter ( new MyFunctionTypeFormatter ( ) ) ;
// If your formatter DOES support children, you'll need this reference too:
fmt . addTypeFormatter ( new MyFunctionTypeFormatter ( circularReferenceTypeFormatter ) ) ;
} ) ;
const program = createProgram ( config ) ;
const parser = createParser ( program , config ) ;
const generator = new SchemaGenerator ( program , parser , formatter , config ) ;
const schema = generator . createSchema ( config . type ) ;
const outputPath = "path/to/output/file" ;
const schemaString = JSON . stringify ( schema , null , 2 ) ;
fs . writeFile ( outputPath , schemaString , ( err ) => {
if ( err ) throw err ;
} ) ;Semelhante à formatação personalizada, estender a análise integrada funciona praticamente da mesma maneira:
// my-constructor-parser.ts
import { Context , StringType , ReferenceType , BaseType , SubNodeParser } from "ts-json-schema-generator" ;
// use typescript exported by TJS to avoid version conflict
import ts from "ts-json-schema-generator" ;
export class MyConstructorParser implements SubNodeParser {
supportsNode ( node : ts . Node ) : boolean {
return node . kind === ts . SyntaxKind . ConstructorType ;
}
createType ( node : ts . Node , context : Context , reference ?: ReferenceType ) : BaseType | undefined {
return new StringType ( ) ; // Treat constructors as strings in this example
}
} import { createProgram , createParser , SchemaGenerator , createFormatter } from "ts-json-schema-generator" ;
import { MyConstructorParser } from "./my-constructor-parser.ts" ;
import fs from "fs" ;
const config = {
path : "path/to/source/file" ,
tsconfig : "path/to/tsconfig.json" ,
type : "*" , // Or <type-name> if you want to generate schema for that one type only
} ;
const program = createProgram ( config ) ;
// We configure the parser an add our custom parser to it.
const parser = createParser ( program , config , ( prs ) => {
prs . addNodeParser ( new MyConstructorParser ( ) ) ;
} ) ;
const formatter = createFormatter ( config ) ;
const generator = new SchemaGenerator ( program , parser , formatter , config ) ;
const schema = generator . createSchema ( config . type ) ;
const outputPath = "path/to/output/file" ;
const schemaString = JSON . stringify ( schema , null , 2 ) ;
fs . writeFile ( outputPath , schemaString , ( err ) => {
if ( err ) throw err ;
} ) ; interfaceenumunion , tuple , type[]Date , RegExp , tipos URLstring , boolean , tipos number"value" , 123 , true , false , null , literais undefinedtypeofkeyofPromise<T> desembrulha para T@format ) yarn --silent run run --path 'test/valid-data/type-mapped-array/*.ts' --type 'MyObject'
yarn --silent run debug --path 'test/valid-data/type-mapped-array/*.ts' --type 'MyObject'
E conecte-se por meio do protocolo do depurador.
AST Explorer é incrível para desenvolvedores desta ferramenta!
A publicação é feita por um processo de pré-lançamento de 2 ramificações, configurado publish-auto.yml . Todas as alterações devem ser baseadas no next branch padrão e são publicadas automaticamente.
next tag de pré-lançamento no NPM. O resultado pode ser instalado com npm install ts-json-schema-generator@nextnext , use a estratégia squash and merge .next para stable usando este link de comparação.next para stable , use a estratégia create a merge commit .
