ts json schema generator
v2.3.0
Versión extendida de https://github.com/xiag-ag/typescript-to-json-schema.
Inspirado en YousefED/typescript-json-schema . Aquí está la lista de diferencias:
typeChecker.getTypeAtLocation() (por lo que probablemente mantenga los alias de tipo correctos)definitions del esquema JSON. Este proyecto es posible gracias a una comunidad de contribuyentes. Damos la bienvenida a contribuciones de cualquier tipo (problemas, código, documentación, ejemplos, pruebas,...). Por favor lea nuestro código de conducta.
Ejecute el generador de esquemas con npx:
npx ts-json-schema-generator --path ' my/project/**/*.ts ' --type ' My.Type.Name 'O instale el paquete y luego ejecútelo
npm install --save ts-json-schema-generator
./node_modules/.bin/ts-json-schema-generator --path ' my/project/**/*.ts ' --type ' My.Type.Name 'Tenga en cuenta que diferentes plataformas (por ejemplo, Windows) pueden usar diferentes separadores de ruta, por lo que es posible que deba ajustar el comando anterior.
También tenga en cuenta que debe citar las rutas con * , de lo contrario, el shell expandirá las rutas y, por lo tanto, solo pasará la primera ruta al generador.
De forma predeterminada, el generador de línea de comandos utilizará el archivo tsconfig.json en el directorio de trabajo actual o el primer directorio principal que contenga un archivo tsconfig.json hasta la raíz del sistema de archivos. Si desea utilizar un archivo tsconfig.json diferente, puede utilizar la opción --tsconfig . En particular, si necesita utilizar diferentes opciones de compilación para tipos, es posible que desee crear un archivo tsconfig.json separado solo para la generación del 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 ;
} ) ; Ejecute el generador de esquemas a través node main.js
Es posible ampliar el formato integrado creando un formateador personalizado y agregándolo al formateador 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 ;
} ) ;De manera similar al formato personalizado, ampliar el análisis integrado funciona prácticamente de la misma manera:
// 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[] tiposDate , RegExp , tipos URLstring , boolean , tipos number"value" , 123 , true , false , null , literales undefinedtypeofkeyofPromise<T> se desenvuelve en 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'
Y conéctese a través del protocolo del depurador.
¡AST Explorer es increíble para los desarrolladores de esta herramienta!
La publicación se realiza mediante un proceso de prelanzamiento de dos ramas, configurado en publish-auto.yml . Todos los cambios deben basarse en la next rama predeterminada y se publican automáticamente.
next etiqueta de prelanzamiento en NPM. El resultado se puede instalar con npm install ts-json-schema-generator@nextnext , utilice la estrategia squash and merge .next al stable usando este enlace de comparación.next a stable , utilice la estrategia create a merge commit .
