feat: enum support (#153)

* feat(config-base): adding useEnums to config

* feat(utils): adding getEnumProperties for parsing schemas

* feat(generateschematypes): handling enum config in generateSchemaTypes

* feat(enum-declaration): splitting enum declaration in its own context

* feat(type-declaration): adding enum support to schemaToTypeAliasDeclaration

* test(schema-to-enum): adding more test cases

* perf(schema-to-type): improving performance when getting schema name

* test(snapshots): updating new test snapshots

* test(convert-numbers-to-words): adding unit tests for converting numbers into words

Author: alan-oliv

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

@@ -0,0 +1,97 @@
+import { OpenAPIObject, SchemaObject } from "openapi3-ts";
+import ts from "typescript";
+import { schemaToEnumDeclaration } from "./schemaToEnumDeclaration";
+import { OpenAPIComponentType } from "./schemaToTypeAliasDeclaration";
+
+describe("schemaToTypeAliasDeclaration", () => {
+  it("should generate a string enums", () => {
+    const schema: SchemaObject = {
+      type: "string",
+      enum: ["AVAILABLE", "PENDING", "SOLD"],
+    };
+
+    expect(printSchema(schema)).toMatchInlineSnapshot(`
+      "export enum Test {
+          AVAILABLE = \\"AVAILABLE\\",
+          PENDING = \\"PENDING\\",
+          SOLD = \\"SOLD\\"
+      }"
+    `);
+  });
+
+  it("should generate a int enum", () => {
+    const schema: SchemaObject = {
+      type: "string",
+      enum: [1, 2, 3],
+    };
+
+    expect(printSchema(schema)).toMatchInlineSnapshot(`
+      "export enum Test {
+          ONE = 1,
+          TWO = 2,
+          THREE = 3
+      }"
+    `);
+  });
+
+  it("should generate a int enum (using big numbers)", () => {
+    const schema: SchemaObject = {
+      type: "string",
+      enum: [0, 7, 15, 100, 1000, 1456, 3217],
+    };
+
+    expect(printSchema(schema)).toMatchInlineSnapshot(`
+      "export enum Test {
+          ZERO = 0,
+          SEVEN = 7,
+          FIFTEEN = 15,
+          ONE_HUNDRED = 100,
+          ONE_THOUSAND = 1000,
+          ONE_THOUSAND_FOUR_HUNDRED_FIFTY_SIX = 1456,
+          THREE_THOUSAND_TWO_HUNDRED_SEVENTEEN = 3217
+      }"
+    `);
+  });
+
+  it("should generate a boolean enum", () => {
+    const schema: SchemaObject = {
+      type: "string",
+      enum: [true, false],
+    };
+
+    expect(printSchema(schema)).toMatchInlineSnapshot(`
+      "export enum Test {
+          True,
+          False
+      }"
+    `);
+  });
+});
+
+const printSchema = (
+  schema: SchemaObject,
+  currentComponent: OpenAPIComponentType = "schemas",
+  components?: OpenAPIObject["components"]
+) => {
+  const nodes = schemaToEnumDeclaration("Test", schema, {
+    currentComponent,
+    openAPIDocument: { components },
+  });
+
+  const sourceFile = ts.createSourceFile(
+    "index.ts",
+    "",
+    ts.ScriptTarget.Latest
+  );
+
+  const printer = ts.createPrinter({
+    newLine: ts.NewLineKind.LineFeed,
+    removeComments: false,
+  });
+
+  return nodes
+    .map((node: ts.Node) =>
+      printer.printNode(ts.EmitHint.Unspecified, node, sourceFile)
+    )
+    .join("\n");
+};

plugins/typescript/src/core/schemaToEnumDeclaration.ts

@@ -0,0 +1,60 @@
+import { pascal } from "case";
+import { SchemaObject } from "openapi3-ts";
+import ts, { factory as f } from "typescript";
+import { convertNumberToWord } from "../utils/getEnumProperties";
+import { Context, getJSDocComment } from "./schemaToTypeAliasDeclaration";
+
+/**
+ * Add Enum support when transforming an OpenAPI Schema Object to Typescript Nodes.
+ *
+ * @param name Name of the schema
+ * @param schema OpenAPI Schema object
+ * @param context Context
+ */
+export const schemaToEnumDeclaration = (
+  name: string,
+  schema: SchemaObject,
+  context: Context
+): ts.Node[] => {
+  const jsDocNode = getJSDocComment(schema, context);
+  const members = getEnumMembers(schema, context);
+  const declarationNode = f.createEnumDeclaration(
+    [f.createModifier(ts.SyntaxKind.ExportKeyword)],
+    pascal(name),
+    members
+  );
+
+  return jsDocNode ? [jsDocNode, declarationNode] : [declarationNode];
+};
+
+function getEnumMembers(
+  schema: SchemaObject,
+  context: Context
+): ts.EnumMember[] {
+  if (!schema.enum || !Array.isArray(schema.enum)) {
+    throw new Error(
+      "The provided schema does not have an 'enum' property or it is not an array."
+    );
+  }
+
+  return schema.enum.map((enumValue, index) => {
+    let enumName: string;
+    let enumValueNode: ts.Expression | undefined = undefined;
+
+    if (typeof enumValue === "string") {
+      enumName = enumValue;
+      enumValueNode = f.createStringLiteral(enumValue);
+    } else if (typeof enumValue === "number") {
+      enumName = convertNumberToWord(enumValue)
+        .toUpperCase()
+        .replace(/[-\s]/g, "_");
+      enumValueNode = f.createNumericLiteral(enumValue);
+    } else if (typeof enumValue === "boolean") {
+      enumName = enumValue ? "True" : "False";
+    } else {
+      throw new Error(`Unsupported enum value type: ${typeof enumValue}`);
+    }
+
+    return f.createEnumMember(f.createIdentifier(enumName), enumValueNode);
+  });
+}

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

@@ -69,6 +69,32 @@ describe("schemaToTypeAliasDeclaration", () => {
     );
   });
 
+  it("should reference to an previously created enum", () => {
+    const schema: SchemaObject = {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          enum: ["AVAILABLE", "PENDING", "SOLD"],
+        },
+      },
+      xml: { name: "pet" },
+    };
+
+    const components: OpenAPIObject["components"] = {
+      schemas: {
+        Pet: schema,
+      },
+    };
+
+    expect(printSchema(schema, "schemas", components, true))
+      .toMatchInlineSnapshot(`
+      "export type Test = {
+          status?: TestStatus;
+      };"
+    `);
+  });
+
   it("should generate nullable enums (strings)", () => {
     const schema: SchemaObject = {
       type: "string",
@@ -879,12 +905,18 @@ describe("schemaToTypeAliasDeclaration", () => {
 const printSchema = (
   schema: SchemaObject,
   currentComponent: OpenAPIComponentType = "schemas",
-  components?: OpenAPIObject["components"]
+  components?: OpenAPIObject["components"],
+  useEnums?: boolean
 ) => {
-  const nodes = schemaToTypeAliasDeclaration("Test", schema, {
-    currentComponent,
-    openAPIDocument: { components },
-  });
+  const nodes = schemaToTypeAliasDeclaration(
+    "Test",
+    schema,
+    {
+      currentComponent,
+      openAPIDocument: { components },
+    },
+    useEnums
+  );
 
   const sourceFile = ts.createSourceFile(
     "index.ts",

plugins/typescript/src/core/schemaToTypeAliasDeclaration.ts

@@ -1,17 +1,17 @@
-import { findKey, get, merge, intersection, omit } from "lodash";
-import { singular } from "pluralize";
+import { pascal } from "case";
+import { findKey, get, intersection, merge, omit } from "lodash";
 import {
   ComponentsObject,
   DiscriminatorObject,
-  isReferenceObject,
-  isSchemaObject,
   OpenAPIObject,
   ReferenceObject,
   SchemaObject,
+  isReferenceObject,
+  isSchemaObject,
 } from "openapi3-ts";
-import ts, { factory as f } from "typescript";
+import { singular } from "pluralize";
 import { isValidIdentifier } from "tsutils";
-import { pascal } from "case";
+import ts, { factory as f } from "typescript";
 import { getReferenceSchema } from "./getReferenceSchema";
 
 type RemoveIndex<T> = {
@@ -37,24 +37,28 @@ export type Context = {
   currentComponent: OpenAPIComponentType | null;
 };
 
+let useEnumsConfigBase: boolean | undefined;
+
 /**
  * Transform an OpenAPI Schema Object to Typescript Nodes (comment & declaration).
  *
- * @param name  Name of the schema
+ * @param name Name of the schema
  * @param schema OpenAPI Schema object
  * @param context Context
  */
 export const schemaToTypeAliasDeclaration = (
   name: string,
   schema: SchemaObject,
-  context: Context
+  context: Context,
+  useEnums?: boolean
 ): ts.Node[] => {
+  useEnumsConfigBase = useEnums;
   const jsDocNode = getJSDocComment(schema, context);
   const declarationNode = f.createTypeAliasDeclaration(
     [f.createModifier(ts.SyntaxKind.ExportKeyword)],
     pascal(name),
     undefined,
-    getType(schema, context)
+    getType(schema, context, name)
   );
 
   return jsDocNode ? [jsDocNode, declarationNode] : [declarationNode];
@@ -68,7 +72,9 @@ export const schemaToTypeAliasDeclaration = (
  */
 export const getType = (
   schema: SchemaObject | ReferenceObject,
-  context: Context
+  context: Context,
+  name?: string,
+  isNodeEnum?: boolean
 ): ts.TypeNode => {
   if (isReferenceObject(schema)) {
     const [hash, topLevel, namespace, name] = schema.$ref.split("/");
@@ -126,7 +132,11 @@ export const getType = (
   }
 
   if (schema.enum) {
-    return f.createUnionTypeNode([
+    if (isNodeEnum) {
+      return f.createTypeReferenceNode(f.createIdentifier(name || ""));
+    }
+
+    const unionTypes = f.createUnionTypeNode([
       ...schema.enum.map((value) => {
         if (typeof value === "string") {
           return f.createLiteralTypeNode(f.createStringLiteral(value));
@@ -143,6 +153,8 @@ export const getType = (
       }),
       ...(schema.nullable ? [f.createLiteralTypeNode(f.createNull())] : []),
     ]);
+
+    return unionTypes;
   }
 
   // Handle implicit object
@@ -198,6 +210,8 @@ export const getType = (
       const members: ts.TypeElement[] = Object.entries(
         schema.properties || {}
       ).map(([key, property]) => {
+        const isEnum = "enum" in property && useEnumsConfigBase;
+
         const propertyNode = f.createPropertySignature(
           undefined,
           isValidIdentifier(key)
@@ -206,7 +220,12 @@ export const getType = (
           schema.required?.includes(key)
             ? undefined
             : f.createToken(ts.SyntaxKind.QuestionToken),
-          getType(property, context)
+          getType(
+            property,
+            context,
+            `${name}${pascal(key)}`.replace(/[^a-zA-Z0-9 ]/g, ""),
+            isEnum
+          )
         );
         const jsDocNode = getJSDocComment(property, context);
         if (jsDocNode) addJSDocToNode(propertyNode, jsDocNode);
@@ -528,7 +547,7 @@ const keysToExpressAsJsDocProperty: Array<keyof RemoveIndex<SchemaObject>> = [
  * @param context
  * @returns JSDoc node
  */
-const getJSDocComment = (
+export const getJSDocComment = (
   schema: SchemaObject,
   context: Context
 ): ts.JSDoc | undefined => {