ts json schema generator herunterladen - ts json schema generator Quellcode herunterladen

ts-json-schema-generator

Erweiterte Version von https://github.com/xiag-ag/typescript-to-json-schema.

Inspiriert von YousefED/typescript-json-schema . Hier ist die Liste der Unterschiede:

Diese Implementierung vermeidet die Verwendung von typeChecker.getTypeAtLocation() (daher werden wahrscheinlich die korrekten Typaliase beibehalten).
Die Verarbeitung von AST und die Formatierung des JSON-Schemas wurden in zwei unabhängige Schritte aufgeteilt
Nicht exportierte Typen, Schnittstellen und Aufzählungen werden im Abschnitt definitions “ des JSON-Schemas nicht angezeigt

Mitwirkende

Dieses Projekt wird durch eine Gemeinschaft von Mitwirkenden ermöglicht. Wir freuen uns über Beiträge jeglicher Art (Probleme, Code, Dokumentation, Beispiele, Tests,...). Bitte lesen Sie unseren Verhaltenskodex.

CLI-Nutzung

Führen Sie den Schemagenerator mit npx aus:

npx ts-json-schema-generator --path ' my/project/**/*.ts ' --type ' My.Type.Name '

Oder installieren Sie das Paket und führen Sie es dann aus

npm install --save ts-json-schema-generator
./node_modules/.bin/ts-json-schema-generator --path ' my/project/**/*.ts ' --type ' My.Type.Name '

Beachten Sie, dass verschiedene Plattformen (z. B. Windows) möglicherweise unterschiedliche Pfadtrennzeichen verwenden, sodass Sie möglicherweise den obigen Befehl anpassen müssen.

Beachten Sie außerdem, dass Sie Pfade mit * in Anführungszeichen setzen müssen, da die Shell sonst die Pfade erweitert und daher nur den ersten Pfad an den Generator übergibt.

Standardmäßig verwendet der Befehlszeilengenerator die Datei tsconfig.json im aktuellen Arbeitsverzeichnis oder das erste übergeordnete Verzeichnis, das eine Datei tsconfig.json bis zum Stammverzeichnis des Dateisystems enthält. Wenn Sie eine andere tsconfig.json Datei verwenden möchten, können Sie die Option --tsconfig verwenden. Insbesondere wenn Sie unterschiedliche Kompilierungsoptionen für Typen verwenden müssen, möchten Sie möglicherweise eine separate tsconfig.json Datei nur für die Schemagenerierung erstellen.

Optionen

  -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

Programmatische Nutzung

 // 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 ;
} ) ;

Führen Sie den Schemagenerator über node main.js aus.

Benutzerdefinierte Formatierung

Die integrierte Formatierung kann erweitert werden, indem ein benutzerdefinierter Formatierer erstellt und zum Hauptformatierer hinzugefügt wird:

Zuerst erstellen wir einen Formatierer, in diesem Fall zum Formatieren von Funktionstypen (beachten Sie, dass ein solcher eingebaut ist):

 // 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 ( ) ) ;
    }
}

Dann fügen wir den Formatierer als untergeordnetes Element zum Kernformatierer hinzu, indem wir den Erweiterungsrückruf verwenden:

 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 ;
} ) ;

Benutzerdefiniertes Parsen

Ähnlich wie bei der benutzerdefinierten Formatierung funktioniert die Erweiterung des integrierten Parsing praktisch auf die gleiche Weise:

Zuerst erstellen wir einen Parser, in diesem Fall zum Parsen von Konstrukttypen:

 // 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
    }
}

Dann fügen wir den Parser mithilfe des Erweiterungsrückrufs als untergeordnetes Element zum Kernparser hinzu:

 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 ;
} ) ;

Aktueller Stand

interface
enum
union , tuple und type[] -Typen
Date , RegExp , URL Typen
string , boolean und number
"value" , 123 , true , false , null , undefined Literale
Typ-Aliase
Generika
typeof
keyof
bedingte Typen
Funktionen
Promise<T> entpackt sich zu T
Überschreibungen (wie @format )

Lokal ausführen

yarn --silent run run --path 'test/valid-data/type-mapped-array/*.ts' --type 'MyObject'

Debuggen

yarn --silent run debug --path 'test/valid-data/type-mapped-array/*.ts' --type 'MyObject'

Und stellen Sie eine Verbindung über das Debugger-Protokoll her.

AST Explorer ist für Entwickler dieses Tools großartig!

Veröffentlichen

Die Veröffentlichung erfolgt über einen Vorabveröffentlichungsprozess mit zwei Zweigen, der in publish-auto.yml konfiguriert ist. Alle Änderungen sollten auf dem standardmäßigen next Zweig basieren und werden automatisch veröffentlicht.

Im Standardzweig vorgenommene PRs werden automatisch für das next Vorabversions-Tag auf NPM bereitgestellt. Das Ergebnis kann mit npm install ts-json-schema-generator@next installiert werden
- Beim Zusammenführen in next verwenden Sie bitte die squash and merge -Strategie.
Um eine neue stabile Version zu veröffentlichen, öffnen Sie über diesen Vergleichslink eine PR von next in stable .
- Wenn Sie von next nach stable zusammenführen, verwenden Sie bitte die Strategie create a merge commit .