fix: remove TSJG prefixes

kitajs · May 23, 2024 · 7ec60d4 · 7ec60d4
1 parent 964546a
commit 7ec60d4
Show file tree

Hide file tree

Showing 23 changed files with 79 additions and 87 deletions.
diff --git a/factory/program.ts b/factory/program.ts
@@ -3,25 +3,25 @@ import * as path from "node:path";
 import normalize from "normalize-path";
 import ts from "typescript";
 import type { CompletedConfig, Config } from "../src/Config.js";
-import { BuildTJSGError } from "../src/Error/Errors.js";
+import { BuildError } from "../src/Error/Errors.js";
 
 function loadTsConfigFile(configFile: string) {
     const raw = ts.sys.readFile(configFile);
 
     if (!raw) {
-        throw new BuildTJSGError({
+        throw new BuildError({
             messageText: `Cannot read config file "${configFile}"`,
         });
     }
 
     const config = ts.parseConfigFileTextToJson(configFile, raw);
 
     if (config.error) {
-        throw new BuildTJSGError(config.error);
+        throw new BuildError(config.error);
     }
 
     if (!config.config) {
-        throw new BuildTJSGError({
+        throw new BuildError({
             messageText: `Invalid parsed config file "${configFile}"`,
         });
     }
@@ -70,7 +70,7 @@ export function createProgram(config: CompletedConfig): ts.Program {
     const rootNames = rootNamesFromPath.length ? rootNamesFromPath : tsconfig.fileNames;
 
     if (!rootNames.length) {
-        throw new BuildTJSGError({
+        throw new BuildError({
             messageText: "No input files",
         });
     }
@@ -81,7 +81,7 @@ export function createProgram(config: CompletedConfig): ts.Program {
         const diagnostics = ts.getPreEmitDiagnostics(program);
 
         if (diagnostics.length) {
-            throw new BuildTJSGError({
+            throw new BuildError({
                 messageText: "Type check error",
                 relatedInformation: [...diagnostics],
             });

diff --git a/src/ChainNodeParser.ts b/src/ChainNodeParser.ts
@@ -1,5 +1,5 @@
 import type ts from "typescript";
-import { UnknownNodeTJSGError } from "./Error/Errors.js";
+import { UnknownNodeError } from "./Error/Errors.js";
 import type { MutableParser } from "./MutableParser.js";
 import type { Context } from "./NodeParser.js";
 import type { SubNodeParser } from "./SubNodeParser.js";
@@ -47,6 +47,6 @@ export class ChainNodeParser implements SubNodeParser, MutableParser {
             }
         }
 
-        throw new UnknownNodeTJSGError(node);
+        throw new UnknownNodeError(node);
     }
 }
diff --git a/src/ChainTypeFormatter.ts b/src/ChainTypeFormatter.ts
@@ -1,4 +1,4 @@
-import { UnknownTypeTJSGError } from "./Error/Errors.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";
@@ -29,6 +29,6 @@ export class ChainTypeFormatter implements SubTypeFormatter, MutableTypeFormatte
             }
         }
 
-        throw new UnknownTypeTJSGError(type);
+        throw new UnknownTypeError(type);
     }
 }
diff --git a/src/Error/BaseError.ts b/src/Error/BaseError.ts
@@ -17,12 +17,12 @@ const isTTY = process.env.TTY || process.stdout.isTTY;
 /**
  * Base error for ts-json-schema-generator
  */
-export abstract class TJSGError extends Error {
+export abstract class BaseError extends Error {
     readonly diagnostic: ts.Diagnostic;
 
     constructor(diagnostic: PartialDiagnostic) {
         super(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
-        this.diagnostic = TJSGError.createDiagnostic(diagnostic);
+        this.diagnostic = BaseError.createDiagnostic(diagnostic);
     }
 
     static createDiagnostic(diagnostic: PartialDiagnostic): ts.Diagnostic {
@@ -37,7 +37,8 @@ export abstract class TJSGError extends Error {
         }
 
         // @ts-expect-error - Differentiates from errors from the TypeScript compiler
-        diagnostic.code = `tjsg - ${diagnostic.code}`;
+        // error TSJ - 100: message
+        diagnostic.code = `J - ${diagnostic.code}`;
 
         return Object.assign(
             {

diff --git a/src/Error/Errors.ts b/src/Error/Errors.ts
@@ -1,9 +1,9 @@
 import ts from "typescript";
-import { PartialDiagnostic, TJSGError } from "./BaseError.js";
+import { type PartialDiagnostic, BaseError } from "./BaseError.js";
 import type { BaseType } from "../Type/BaseType.js";
-import { JSONSchema7 } from "json-schema";
+import type { JSONSchema7 } from "json-schema";
 
-export class UnknownNodeTJSGError extends TJSGError {
+export class UnknownNodeError extends BaseError {
     constructor(readonly node: ts.Node) {
         super({
             code: 100,
@@ -13,7 +13,7 @@ export class UnknownNodeTJSGError extends TJSGError {
     }
 }
 
-export class UnknownTypeTJSGError extends TJSGError {
+export class UnknownTypeError extends BaseError {
     constructor(readonly type: BaseType) {
         super({
             code: 101,
@@ -22,7 +22,7 @@ export class UnknownTypeTJSGError extends TJSGError {
     }
 }
 
-export class RootlessTJSGError extends TJSGError {
+export class RootlessError extends BaseError {
     constructor(readonly fullName: string) {
         super({
             code: 102,
@@ -31,7 +31,7 @@ export class RootlessTJSGError extends TJSGError {
     }
 }
 
-export class MultipleDefinitionsTJSGError extends TJSGError {
+export class MultipleDefinitionsError extends BaseError {
     constructor(
         readonly name: string,
         readonly defA: BaseType,
@@ -44,7 +44,7 @@ export class MultipleDefinitionsTJSGError extends TJSGError {
     }
 }
 
-export class LogicTJSGError extends TJSGError {
+export class LogicError extends BaseError {
     constructor(
         readonly node: ts.Node,
         messageText: string,
@@ -57,7 +57,7 @@ export class LogicTJSGError extends TJSGError {
     }
 }
 
-export class ExpectationFailedTJSGError extends TJSGError {
+export class ExpectationFailedError extends BaseError {
     constructor(
         messageText: string,
         readonly node?: ts.Node,
@@ -70,7 +70,7 @@ export class ExpectationFailedTJSGError extends TJSGError {
     }
 }
 
-export class TypeTJSGError extends TJSGError {
+export class JsonTypeError extends BaseError {
     constructor(
         messageText: string,
         readonly type: BaseType,
@@ -82,7 +82,7 @@ export class TypeTJSGError extends TJSGError {
     }
 }
 
-export class DefinitionTJSGError extends TJSGError {
+export class DefinitionError extends BaseError {
     constructor(
         messageText: string,
         readonly definition: JSONSchema7,
@@ -93,7 +93,7 @@ export class DefinitionTJSGError extends TJSGError {
         });
     }
 }
-export class BuildTJSGError extends TJSGError {
+export class BuildError extends BaseError {
     constructor(diag: Omit<PartialDiagnostic, "code">) {
         super({
             code: 108,

diff --git a/src/NodeParser/IndexedAccessTypeNodeParser.ts b/src/NodeParser/IndexedAccessTypeNodeParser.ts
@@ -11,7 +11,7 @@ import { TupleType } from "../Type/TupleType.js";
 import { UnionType } from "../Type/UnionType.js";
 import { derefType } from "../Utils/derefType.js";
 import { getTypeByKey } from "../Utils/typeKeys.js";
-import { LogicTJSGError } from "../Error/Errors.js";
+import { LogicError } from "../Error/Errors.js";
 
 export class IndexedAccessTypeNodeParser implements SubNodeParser {
     public constructor(
@@ -61,7 +61,7 @@ export class IndexedAccessTypeNodeParser implements SubNodeParser {
         const indexTypes = indexType instanceof UnionType ? indexType.getTypes() : [indexType];
         const propertyTypes = indexTypes.map((type) => {
             if (!(type instanceof LiteralType || type instanceof StringType || type instanceof NumberType)) {
-                throw new LogicTJSGError(
+                throw new LogicError(
                     node,
                     `Unexpected type "${type.getId()}" (expected "LiteralType.js" or "StringType.js" or "NumberType.js")`,
                 );
@@ -78,13 +78,10 @@ export class IndexedAccessTypeNodeParser implements SubNodeParser {
                         return objectType;
                     }
 
-                    throw new LogicTJSGError(
-                        node,
-                        `Invalid index "${type.getValue()}" in type "${objectType.getId()}"`,
-                    );
+                    throw new LogicError(node, `Invalid index "${type.getValue()}" in type "${objectType.getId()}"`);
                 }
 
-                throw new LogicTJSGError(node, `No additional properties in type "${objectType.getId()}"`);
+                throw new LogicError(node, `No additional properties in type "${objectType.getId()}"`);
             }
 
             return propertyType;

diff --git a/src/NodeParser/IntersectionNodeParser.ts b/src/NodeParser/IntersectionNodeParser.ts
@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { ExpectationFailedTJSGError } from "../Error/Errors.js";
+import { ExpectationFailedError } from "../Error/Errors.js";
 import type { Context, NodeParser } from "../NodeParser.js";
 import type { SubNodeParser } from "../SubNodeParser.js";
 import type { BaseType } from "../Type/BaseType.js";
@@ -114,5 +114,5 @@ export function translate(types: BaseType[]): BaseType {
         return new UnionType(result);
     }
 
-    throw new ExpectationFailedTJSGError("Could not translate intersection to union.");
+    throw new ExpectationFailedError("Could not translate intersection to union.");
 }
diff --git a/src/NodeParser/IntrinsicNodeParser.ts b/src/NodeParser/IntrinsicNodeParser.ts
@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { LogicTJSGError } from "../Error/Errors.js";
+import { LogicError } from "../Error/Errors.js";
 import type { Context } from "../NodeParser.js";
 import type { SubNodeParser } from "../SubNodeParser.js";
 import type { BaseType } from "../Type/BaseType.js";
@@ -23,7 +23,7 @@ export class IntrinsicNodeParser implements SubNodeParser {
         const method = intrinsicMethods[methodName];
 
         if (!method) {
-            throw new LogicTJSGError(node, `Unknown intrinsic method: ${methodName}`);
+            throw new LogicError(node, `Unknown intrinsic method: ${methodName}`);
         }
 
         const literals = extractLiterals(context.getArguments()[0])
@@ -40,7 +40,7 @@ function getParentName(node: ts.KeywordTypeNode): string {
     const parent = node.parent;
 
     if (!ts.isTypeAliasDeclaration(parent)) {
-        throw new LogicTJSGError(node, "Only intrinsics part of a TypeAliasDeclaration are supported.");
+        throw new LogicError(node, "Only intrinsics part of a TypeAliasDeclaration are supported.");
     }
 
     return parent.name.text;

diff --git a/src/NodeParser/MappedTypeNodeParser.ts b/src/NodeParser/MappedTypeNodeParser.ts
@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { ExpectationFailedTJSGError } from "../Error/Errors.js";
+import { ExpectationFailedError } from "../Error/Errors.js";
 import { Context, NodeParser } from "../NodeParser.js";
 import { SubNodeParser } from "../SubNodeParser.js";
 import { AnnotatedType } from "../Type/AnnotatedType.js";
@@ -92,7 +92,7 @@ export class MappedTypeNodeParser implements SubNodeParser {
             return new ObjectType(id, [], [], false);
         }
 
-        throw new ExpectationFailedTJSGError(
+        throw new ExpectationFailedError(
             `Unexpected key type "${
                 constraintType ? constraintType.getId() : constraintType
             }" for this node. (expected "UnionType" or "StringType")`,

diff --git a/src/NodeParser/PrefixUnaryExpressionNodeParser.ts b/src/NodeParser/PrefixUnaryExpressionNodeParser.ts
@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { ExpectationFailedTJSGError } from "../Error/Errors.js";
+import { ExpectationFailedError } from "../Error/Errors.js";
 import type { Context, NodeParser } from "../NodeParser.js";
 import type { SubNodeParser } from "../SubNodeParser.js";
 import type { BaseType } from "../Type/BaseType.js";
@@ -27,10 +27,10 @@ export class PrefixUnaryExpressionNodeParser implements SubNodeParser {
                     return new LiteralType(!operand.getValue());
             }
 
-            throw new ExpectationFailedTJSGError("Unsupported prefix unary operator", node);
+            throw new ExpectationFailedError("Unsupported prefix unary operator", node);
         }
 
-        throw new ExpectationFailedTJSGError(
+        throw new ExpectationFailedError(
             `Expected operand to be "LiteralType" but is "${operand ? operand.constructor.name : operand}"`,
             node,
         );

diff --git a/src/NodeParser/PromiseNodeParser.ts b/src/NodeParser/PromiseNodeParser.ts
@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { ExpectationFailedTJSGError } from "../Error/Errors.js";
+import { ExpectationFailedError } from "../Error/Errors.js";
 import { Context, type NodeParser } from "../NodeParser.js";
 import type { SubNodeParser } from "../SubNodeParser.js";
 import { AliasType } from "../Type/AliasType.js";
@@ -64,7 +64,7 @@ export class PromiseNodeParser implements SubNodeParser {
         const awaitedNode = this.typeChecker.typeToTypeNode(awaitedType, undefined, ts.NodeBuilderFlags.IgnoreErrors);
 
         if (!awaitedNode) {
-            throw new ExpectationFailedTJSGError("Could not find awaited node", node);
+            throw new ExpectationFailedError("Could not find awaited node", node);
         }
 
         const baseNode = this.childNodeParser.createType(awaitedNode, new Context(node));
@@ -86,7 +86,7 @@ export class PromiseNodeParser implements SubNodeParser {
     ) {
         if (ts.isExpressionWithTypeArguments(node)) {
             if (!ts.isHeritageClause(node.parent)) {
-                throw new ExpectationFailedTJSGError(
+                throw new ExpectationFailedError(
                     "Expected ExpressionWithTypeArguments to have a HeritageClause parent",
                     node.parent,
                 );

diff --git a/src/NodeParser/StringTemplateLiteralNodeParser.ts b/src/NodeParser/StringTemplateLiteralNodeParser.ts
@@ -6,7 +6,7 @@ import { LiteralType } from "../Type/LiteralType.js";
 import { StringType } from "../Type/StringType.js";
 import { UnionType } from "../Type/UnionType.js";
 import { extractLiterals } from "../Utils/extractLiterals.js";
-import { UnknownTypeTJSGError } from "../Error/Errors.js";
+import { UnknownTypeError } from "../Error/Errors.js";
 
 export class StringTemplateLiteralNodeParser implements SubNodeParser {
     public constructor(protected childNodeParser: NodeParser) {}
@@ -41,7 +41,7 @@ export class StringTemplateLiteralNodeParser implements SubNodeParser {
 
             return new UnionType(expandedTypes);
         } catch (error) {
-            if (error instanceof UnknownTypeTJSGError) {
+            if (error instanceof UnknownTypeError) {
                 return new StringType();
             }
 

diff --git a/src/NodeParser/TypeofNodeParser.ts b/src/NodeParser/TypeofNodeParser.ts
@@ -8,7 +8,7 @@ import { getKey } from "../Utils/nodeKey.js";
 import { LiteralType } from "../Type/LiteralType.js";
 import { NeverType } from "../Type/NeverType.js";
 import { FunctionType } from "../Type/FunctionType.js";
-import { LogicTJSGError } from "../Error/Errors.js";
+import { LogicError } from "../Error/Errors.js";
 
 export class TypeofNodeParser implements SubNodeParser {
     public constructor(
@@ -33,7 +33,7 @@ export class TypeofNodeParser implements SubNodeParser {
                 return new NeverType();
             }
 
-            throw new LogicTJSGError(node, `No value declaration found for symbol "${symbol.name}"`);
+            throw new LogicError(node, `No value declaration found for symbol "${symbol.name}"`);
         }
 
         if (ts.isEnumDeclaration(valueDec)) {
@@ -67,10 +67,7 @@ export class TypeofNodeParser implements SubNodeParser {
             return new FunctionType(<ts.FunctionDeclaration>valueDec);
         }
 
-        throw new LogicTJSGError(
-            valueDec,
-            `Invalid type query for this declaration. (ts.SyntaxKind = ${valueDec.kind})`,
-        );
+        throw new LogicError(valueDec, `Invalid type query for this declaration. (ts.SyntaxKind = ${valueDec.kind})`);
     }
 
     protected createObjectFromEnum(node: ts.EnumDeclaration, context: Context, reference?: ReferenceType): ObjectType {
@@ -91,7 +88,7 @@ export class TypeofNodeParser implements SubNodeParser {
             } else if (type instanceof LiteralType && typeof type.getValue() === "number") {
                 type = new LiteralType(+type.getValue() + 1);
             } else {
-                throw new LogicTJSGError(member.name, `Enum initializer missing for "${name}"`);
+                throw new LogicError(member.name, `Enum initializer missing for "${name}"`);
             }
 
             return new ObjectProperty(name, type, true);