Added diagnostics to all errors

factory/program.ts

@@ -1,44 +1,47 @@
 import * as glob from "glob";
-import * as path from "path";
-import ts from "typescript";
+import * as path from "node:path";
 import normalize from "normalize-path";
-
-import { CompletedConfig, Config } from "../src/Config.js";
-import { DiagnosticError } from "../src/Error/DiagnosticError.js";
-import { LogicError } from "../src/Error/LogicError.js";
-import { NoRootNamesError } from "../src/Error/NoRootNamesError.js";
-import { NoTSConfigError } from "../src/Error/NoTSConfigError.js";
+import ts from "typescript";
+import type { CompletedConfig, Config } from "../src/Config.js";
+import { BuildError } from "../src/Error/Errors.js";
 
 function loadTsConfigFile(configFile: string) {
  const raw = ts.sys.readFile(configFile);
- if (raw) {
- const config = ts.parseConfigFileTextToJson(configFile, raw);
 
-  if (config.error) {
-  throw new DiagnosticError([config.error]);
- } else if (!config.config) {
-  throw new LogicError(`Invalid parsed config file "${configFile}"`);
-  }
+ if (!raw) {
+ throw new BuildError({
+  messageText: `Cannot read config file "${configFile}"`,
+ });
+ }
 
- const parseResult = ts.parseJsonConfigFileContent(
- config.config,
- ts.sys,
- path.resolve(path.dirname(configFile)),
- {},
- configFile,
- );
- parseResult.options.noEmit = true;
- delete parseResult.options.out;
- delete parseResult.options.outDir;
- delete parseResult.options.outFile;
- delete parseResult.options.declaration;
- delete parseResult.options.declarationDir;
- delete parseResult.options.declarationMap;
+ const config = ts.parseConfigFileTextToJson(configFile, raw);
 
- return parseResult;
- } else {
- throw new NoTSConfigError();
+ if (config.error) {
+ throw new BuildError(config.error);
  }
+
+ if (!config.config) {
+ throw new BuildError({
+ messageText: `Invalid parsed config file "${configFile}"`,
+ });
+ }
+
+ const parseResult = ts.parseJsonConfigFileContent(
+ config.config,
+ ts.sys,
+ path.resolve(path.dirname(configFile)),
+ {},
+ configFile,
+ );
+ parseResult.options.noEmit = true;
+ delete parseResult.options.out;
+ delete parseResult.options.outDir;
+ delete parseResult.options.outFile;
+ delete parseResult.options.declaration;
+ delete parseResult.options.declarationDir;
+ delete parseResult.options.declarationMap;
+
+ return parseResult;
 }
 
 function getTsConfig(config: Config) {
@@ -67,15 +70,21 @@
  const rootNames = rootNamesFromPath.length ? rootNamesFromPath : tsconfig.fileNames;
 
  if (!rootNames.length) {
- throw new NoRootNamesError();
+ throw new BuildError({
+ messageText: "No input files",
+ });
  }
 
  const program: ts.Program = ts.createProgram(rootNames, tsconfig.options);
 
  if (!config.skipTypeCheck) {
  const diagnostics = ts.getPreEmitDiagnostics(program);
+
  if (diagnostics.length) {
- throw new DiagnosticError(diagnostics);
+ throw new BuildError({
+ messageText: "Type check error",
+ relatedInformation: [...diagnostics],
+ });
  }
  }
 

index.ts

@@ -1,20 +1,12 @@
 export * from "./src/Error/BaseError.js";
-export * from "./src/Error/DiagnosticError.js";
-export * from "./src/Error/LogicError.js";
-export * from "./src/Error/NoRootNamesError.js";
-export * from "./src/Error/NoRootTypeError.js";
-export * from "./src/Error/NoTSConfigError.js";
-export * from "./src/Error/UnknownNodeError.js";
-export * from "./src/Error/UnknownTypeError.js";
+export * from "./src/Error/Errors.js";
 
 export * from "./src/Config.js";
 
 export * from "./src/Utils/allOfDefinition.js";
-export * from "./src/Utils/assert.js";
 export * from "./src/Utils/deepMerge.js";
 export * from "./src/Utils/derefType.js";
 export * from "./src/Utils/extractLiterals.js";
-export * from "./src/Utils/formatError.js";
 export * from "./src/Utils/hasJsDocTag.js";
 export * from "./src/Utils/intersectionOfArrays.js";
 export * from "./src/Utils/isAssignableTo.js";

src/ChainNodeParser.ts

@@ -1,9 +1,9 @@
-import ts from "typescript";
-import { UnknownNodeError } from "./Error/UnknownNodeError.js";
-import { MutableParser } from "./MutableParser.js";
-import { Context } from "./NodeParser.js";
-import { SubNodeParser } from "./SubNodeParser.js";
-import { BaseType } from "./Type/BaseType.js";
+import type ts from "typescript";
+import { UnknownNodeError } from "./Error/Errors.js";
+import type { MutableParser } from "./MutableParser.js";
+import type { Context } from "./NodeParser.js";
+import type { SubNodeParser } from "./SubNodeParser.js";
+import type { BaseType } from "./Type/BaseType.js";
 import { ReferenceType } from "./Type/ReferenceType.js";
 
 export class ChainNodeParser implements SubNodeParser, MutableParser {
@@ -32,21 +32,21 @@
  const contextCacheKey = context.getCacheKey();
  let type = typeCache.get(contextCacheKey);
  if (!type) {
- type = this.getNodeParser(node, context).createType(node, context, reference);
+ type = this.getNodeParser(node).createType(node, context, reference);
  if (!(type instanceof ReferenceType)) {
  typeCache.set(contextCacheKey, type);
  }
  }
  return type;
  }
 
- protected getNodeParser(node: ts.Node, context: Context): SubNodeParser {
+ protected getNodeParser(node: ts.Node): SubNodeParser {
  for (const nodeParser of this.nodeParsers) {
  if (nodeParser.supportsNode(node)) {
  return nodeParser;
  }
  }
 
- throw new UnknownNodeError(node, context.getReference());
+ throw new UnknownNodeError(node);
  }
 }

src/ChainTypeFormatter.ts

@@ -1,8 +1,8 @@
-import { UnknownTypeError } from "./Error/UnknownTypeError.js";
-import { MutableTypeFormatter } from "./MutableTypeFormatter.js";
-import { Definition } from "./Schema/Definition.js";
-import { SubTypeFormatter } from "./SubTypeFormatter.js";
-import { BaseType } from "./Type/BaseType.js";
+import { UnknownTypeError } from "./Error/Errors.js";
+import type { MutableTypeFormatter } from "./MutableTypeFormatter.js";
+import type { Definition } from "./Schema/Definition.js";
+import type { SubTypeFormatter } from "./SubTypeFormatter.js";
+import type { BaseType } from "./Type/BaseType.js";
 
 export class ChainTypeFormatter implements SubTypeFormatter, MutableTypeFormatter {
  public constructor(protected typeFormatters: SubTypeFormatter[]) {}

src/Error/BaseError.ts

@@ -1,5 +1,63 @@
+import ts from "typescript";
+
+export type PartialDiagnostic = Omit<ts.Diagnostic, "category" | "file" | "start" | "length"> & {
+ file?: ts.SourceFile;
+ start?: number;
+ length?: number;
+
+ /** If we should populate `file`, `source`, `start` and `length` with this node information */
+ node?: ts.Node;
+
+ /** @default Error */
+ category?: ts.DiagnosticCategory;
+};
+
+const isTTY = process.env.TTY || process.stdout.isTTY;
+
+/**
+ * Base error for ts-json-schema-generator
+ */
 export abstract class BaseError extends Error {
- public constructor(message?: string) {
- super(message);
+ readonly diagnostic: ts.Diagnostic;
+
+ constructor(diagnostic: PartialDiagnostic) {
+ super(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+ this.diagnostic = BaseError.createDiagnostic(diagnostic);
+ }
+
+ static createDiagnostic(diagnostic: PartialDiagnostic): ts.Diagnostic {
+ // Swap the node for the file, source, start and length properties
+ // sourceless nodes cannot be referenced in the diagnostic
+ if (diagnostic.node && diagnostic.node.pos !== -1) {
+ diagnostic.file = diagnostic.node.getSourceFile();
+ diagnostic.start = diagnostic.node.getStart();
+ diagnostic.length = diagnostic.node.getWidth();
+
+ diagnostic.node = undefined;
+ }
+
+ // @ts-expect-error - Differentiates from errors from the TypeScript compiler
+ // error TSJ - 100: message
+ diagnostic.code = `J - ${diagnostic.code}`;
+
+ return Object.assign(
+ {
+ category: ts.DiagnosticCategory.Error,
+ file: undefined,
+ length: 0,
+ start: 0,
+ },
+ diagnostic,
+ );
+ }
+
+ format() {
+ const formatter = isTTY ? ts.formatDiagnosticsWithColorAndContext : ts.formatDiagnostics;
+
+ return formatter([this.diagnostic], {
+ getCanonicalFileName: (fileName) => fileName,
+ getCurrentDirectory: () => "",
+ getNewLine: () => "\n",
+ });
  }
 }

src/Error/Errors.ts

@@ -0,0 +1,103 @@
+import ts from "typescript";
+import { type PartialDiagnostic, BaseError } from "./BaseError.js";
+import type { BaseType } from "../Type/BaseType.js";
+import type { JSONSchema7 } from "json-schema";
+
+export class UnknownNodeError extends BaseError {
+ constructor(readonly node: ts.Node) {
+ super({
+ code: 100,
+ node,
+ messageText: `Unknown node of kind "${ts.SyntaxKind[node.kind]}"`,
+ });
+ }
+}
+
+export class UnknownTypeError extends BaseError {
+ constructor(readonly type: BaseType) {
+ super({
+ code: 101,
+ messageText: `Unknown type "${type.getId()}"`,
+ });
+ }
+}
+
+export class RootlessError extends BaseError {
+ constructor(readonly fullName: string) {
+ super({
+ code: 102,
+ messageText: `No root type "${fullName}" found`,
+ });
+ }
+}
+
+export class MultipleDefinitionsError extends BaseError {
+ constructor(
+ readonly name: string,
+ readonly defA: BaseType,
+ readonly defB?: BaseType,
+ ) {
+ super({
+ code: 103,
+ messageText: `Type "${name}" has multiple definitions.`,
+ });
+ }
+}
+
+export class LogicError extends BaseError {
+ constructor(
+ readonly node: ts.Node,
+ messageText: string,
+ ) {
+ super({
+ code: 104,
+ messageText,
+ node,
+ });
+ }
+}
+
+export class ExpectationFailedError extends BaseError {
+ constructor(
+ messageText: string,
+ readonly node?: ts.Node,
+ ) {
+ super({
+ code: 105,
+ messageText,
+ node,
+ });
+ }
+}
+
+export class JsonTypeError extends BaseError {
+ constructor(
+ messageText: string,
+ readonly type: BaseType,
+ ) {
+ super({
+ code: 106,
+ messageText,
+ });
+ }
+}
+
+export class DefinitionError extends BaseError {
+ constructor(
+ messageText: string,
+ readonly definition: JSONSchema7,
+ ) {
+ super({
+ code: 107,
+ messageText,
+ });
+ }
+}
+export class BuildError extends BaseError {
+ constructor(diag: Omit<PartialDiagnostic, "code">) {
+ super({
+ code: 108,
+ ...diag,
+ });
+ }
+}