fix(typescript): Handle invalid type names

Author: sschw

plugins/typescript/src/core/schemaToTypeAliasDeclaration.test.ts

@@ -946,6 +946,30 @@ describe("schemaToTypeAliasDeclaration", () => {
       `);
     });
 
+    it("should generate valid identifier from number name", () => {
+      const schema: SchemaObject = {};
+
+      expect(printSchema(schema, "200")).toMatchInlineSnapshot(`
+        "export type TwoHundred = void;"
+      `);
+    });
+
+    it("should generate valid identifier from symbol name", () => {
+      const schema: SchemaObject = {};
+
+      expect(printSchema(schema, "-")).toMatchInlineSnapshot(`
+        "export type _ = void;"
+      `);
+    });
+
+    it("should generate valid identifier from invalid name", () => {
+      const schema: SchemaObject = {};
+
+      expect(printSchema(schema, "🙂")).toMatchInlineSnapshot(`
+        "export type _ = void;"
+      `);
+    });
+
     it("should generate a `never` if the combined type is broken", () => {
       const schema: SchemaObject = {
         allOf: [{ type: "string" }, { type: "number" }],

plugins/typescript/src/core/schemaToTypeAliasDeclaration.ts

@@ -11,15 +11,20 @@ import {
 } from "openapi3-ts/oas30";
 import { singular } from "pluralize";
 import { isValidIdentifier } from "tsutils";
-import ts, { factory as f } from "typescript";
+import ts, {
+  factory as f,
+  isIdentifierPart,
+  isIdentifierStart,
+} from "typescript";
+import { convertNumberToWord } from "../utils/getEnumProperties";
 import { getReferenceSchema } from "./getReference";
 
 type RemoveIndex<T> = {
   [P in keyof T as string extends P
-    ? never
-    : number extends P
-      ? never
-      : P]: T[P];
+  ? never
+  : number extends P
+  ? never
+  : P]: T[P];
 };
 
 export type OpenAPIComponentType = Extract<
@@ -56,11 +61,37 @@ export const schemaToTypeAliasDeclaration = (
   const jsDocNode = isSchemaObject(schema)
     ? getJSDocComment(schema, context)
     : undefined;
+
+  let identifier = pascal(name);
+
+  if (identifier.length > 0 && !isNaN(Number(identifier))) {
+    // If the identifier can be cast to a number, convert it to a word.
+    identifier = pascal(convertNumberToWord(Number(identifier)));
+  } else {
+    // If the identifier does not start with a valid character but valid identifier part, prefix it with an underscore.
+    if (
+      !isIdentifierStart(identifier.charCodeAt(0), ts.ScriptTarget.Latest) &&
+      isIdentifierPart(identifier.charCodeAt(0), ts.ScriptTarget.Latest)
+    ) {
+      identifier = `_${identifier}`;
+    }
+
+    // If the identifier is still not valid, remove invalid characters.
+    if (!isValidIdentifier(identifier)) {
+      identifier = identifier.replace(/[^a-zA-Z0-9_]/g, "");
+    }
+
+    // If the identifier is now empty, set it to "_".
+    if (identifier.length === 0) {
+      identifier = "_";
+    }
+  }
+
   const declarationNode = f.createTypeAliasDeclaration(
     [f.createModifier(ts.SyntaxKind.ExportKeyword)],
-    pascal(name),
+    identifier,
     undefined,
-    getType(schema, context, name)
+    getType(schema, context, identifier)
   );
 
   return jsDocNode ? [jsDocNode, declarationNode] : [declarationNode];
@@ -89,11 +120,11 @@ export const getType = (
 
     let refNode: ts.TypeNode = f.createTypeReferenceNode(
       namespace === context.currentComponent
-        ? f.createIdentifier(pascal(name))
+        ? f.createIdentifier(name)
         : f.createQualifiedName(
-            f.createIdentifier(pascal(namespace)),
-            f.createIdentifier(pascal(name))
-          )
+          f.createIdentifier(pascal(namespace)),
+          f.createIdentifier(name)
+        )
     );
 
     for (let i = 0; i < propertyPath.length; i++) {
@@ -173,7 +204,7 @@ export const getType = (
 
   if (schema.enum) {
     if (isNodeEnum) {
-      return f.createTypeReferenceNode(f.createIdentifier(pascal(name || "")));
+      return f.createTypeReferenceNode(f.createIdentifier(name || ""));
     }
 
     const unionTypes = f.createUnionTypeNode([
@@ -287,9 +318,9 @@ export const getType = (
         return withNullable(
           members.length > 0
             ? f.createIntersectionTypeNode([
-                f.createTypeLiteralNode(members),
-                f.createTypeLiteralNode([additionalPropertiesNode]),
-              ])
+              f.createTypeLiteralNode(members),
+              f.createTypeLiteralNode([additionalPropertiesNode]),
+            ])
             : f.createTypeLiteralNode([additionalPropertiesNode]),
           schema.nullable
         );
@@ -618,16 +649,16 @@ export const getJSDocComment = (
   // `allOf` can add some documentation to the schema, let’s merge all items as first step
   const schemaWithAllOfResolved = schema.allOf
     ? schema.allOf.reduce<SchemaObject>((mem, allOfItem) => {
-        if (isReferenceObject(allOfItem)) {
-          const referenceSchema = getReferenceSchema(
-            allOfItem.$ref,
-            context.openAPIDocument.components
-          );
-          return mergeSchemas(mem, referenceSchema).mergedSchema;
-        } else {
-          return mergeSchemas(mem, allOfItem).mergedSchema;
-        }
-      }, schema)
+      if (isReferenceObject(allOfItem)) {
+        const referenceSchema = getReferenceSchema(
+          allOfItem.$ref,
+          context.openAPIDocument.components
+        );
+        return mergeSchemas(mem, referenceSchema).mergedSchema;
+      } else {
+        return mergeSchemas(mem, allOfItem).mergedSchema;
+      }
+    }, schema)
     : schema;
 
   const getJsDocIdentifier = (value: unknown) => {