Schema resolver initial tags update

Author: monikaboz

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@povio/openapi-codegen-cli",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "main": "./dist/index.js",
   "bin": {
     "openapi-codegen": "./dist/sh.js"

src/generators/const/js.const.ts

@@ -0,0 +1,37 @@
+export const RESERVED_WORDS = [
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+];

src/generators/const/openapi.const.ts

@@ -19,3 +19,4 @@ export const ALLOWED_METHODS = [
   "trace",
 ] as Array<OpenAPIV3.HttpMethods>;
 export const PRIMITIVE_TYPE_LIST = ["string", "number", "integer", "boolean"];
+export const COMPOSITE_KEYWORDS = ["allOf", "anyOf", "oneOf"] as (keyof OpenAPIV3.SchemaObject)[];

src/generators/core/SchemaResolver.class.ts

@@ -1,5 +1,5 @@
 import { OpenAPIV3 } from "openapi-types";
-import { ALLOWED_METHODS } from "../const/openapi.const";
+import { ALLOWED_METHODS, COMPOSITE_KEYWORDS } from "../const/openapi.const";
 import { GenerateOptions } from "../types/options";
 import { pick } from "../utils/object.utils";
 import {
@@ -155,24 +155,6 @@ export class SchemaResolver {
   }
 
   private initializeSchemaTags() {
-    const getSchemaRefs = (
-      schema: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | undefined,
-    ): OpenAPIV3.ReferenceObject[] => {
-      const schemaRefObjs: OpenAPIV3.ReferenceObject[] = [];
-      if (!schema) {
-        return schemaRefObjs;
-      }
-
-      if (isReferenceObject(schema)) {
-        schemaRefObjs.push(schema);
-      } else if (schema.allOf || schema.anyOf || schema.oneOf) {
-        const schemaObjs = schema.allOf ?? schema.anyOf ?? schema.oneOf ?? [];
-        schemaObjs.forEach((schema) => schemaRefObjs.push(...getSchemaRefs(schema)));
-      }
-
-      return schemaRefObjs;
-    };
-
     for (const path in this.openApiDoc.paths) {
       const pathItemObj = this.openApiDoc.paths[path] as OpenAPIV3.PathItemObject;
 
@@ -184,29 +166,30 @@ export class SchemaResolver {
           continue;
         }
 
-        // Collect all parameter objects that are references
         const schemaRefObjs = [] as OpenAPIV3.ReferenceObject[];
+
+        // Collect all referenced schemas in parameter objects
         operation.parameters?.map((param) => {
-          schemaRefObjs.push(...getSchemaRefs((param as OpenAPIV3.ParameterObject).schema));
+          schemaRefObjs.push(...this.getOperationSchemaRefs((param as OpenAPIV3.ParameterObject).schema));
         });
 
-        // Collect all requestBody objects that are references
+        // Collect all referenced schemas in requestBody objects
         if (operation.requestBody) {
           const requestBodyObj = this.resolveObject(operation.requestBody);
           const mediaTypes = Object.keys(requestBodyObj.content ?? {});
           const matchingMediaType = mediaTypes.find(isParamMediaTypeAllowed);
           if (matchingMediaType) {
-            schemaRefObjs.push(...getSchemaRefs(requestBodyObj.content?.[matchingMediaType]?.schema));
+            schemaRefObjs.push(...this.getOperationSchemaRefs(requestBodyObj.content?.[matchingMediaType]?.schema));
           }
         }
 
-        // Collect all main response objects that are references
+        // Collect all referenced schemas in main response objects
         for (const statusCode in operation.responses) {
           const responseObj = <OpenAPIV3.ResponseObject>this.resolveObject(operation.responses[statusCode]);
           const mediaTypes = Object.keys(responseObj.content ?? {});
           const matchingMediaType = mediaTypes.find(isMediaTypeAllowed);
           if (matchingMediaType) {
-            schemaRefObjs.push(...getSchemaRefs(responseObj.content?.[matchingMediaType]?.schema));
+            schemaRefObjs.push(...this.getOperationSchemaRefs(responseObj.content?.[matchingMediaType]?.schema));
           }
         }
 
@@ -228,4 +211,34 @@ export class SchemaResolver {
       }
     }
   }
+
+  private getOperationSchemaRefs(
+    schema: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | undefined,
+  ): OpenAPIV3.ReferenceObject[] {
+    if (!schema) {
+      return [];
+    }
+
+    const schemaRefObjs: OpenAPIV3.ReferenceObject[] = [];
+
+    if (isReferenceObject(schema)) {
+      schemaRefObjs.push(schema);
+    }
+
+    const schemaObj = schema as OpenAPIV3.SchemaObject;
+    if (COMPOSITE_KEYWORDS.some((prop) => prop in schemaObj && schemaObj[prop])) {
+      const schemaObjs = schemaObj.allOf ?? schemaObj.anyOf ?? schemaObj.oneOf ?? [];
+      schemaObjs.forEach((schema) => schemaRefObjs.push(...this.getOperationSchemaRefs(schema)));
+    }
+    if (schemaObj.properties) {
+      Object.values(schemaObj.properties).forEach((schema) =>
+        schemaRefObjs.push(...this.getOperationSchemaRefs(schema)),
+      );
+    }
+    if (schemaObj.type === "array") {
+      schemaRefObjs.push(...this.getOperationSchemaRefs((schema as OpenAPIV3.ArraySchemaObject).items));
+    }
+
+    return schemaRefObjs;
+  }
 }

src/generators/core/openapi/getSchemaRefsDependencyGraph.ts

@@ -1,4 +1,5 @@
 import { OpenAPIV3 } from "openapi-types";
+import { COMPOSITE_KEYWORDS } from "src/generators/const/openapi.const";
 import { isReferenceObject } from "src/generators/utils/openapi.utils";
 
 export function getSchemaRefsDependencyGraph({
@@ -51,15 +52,14 @@ function visit({
     return;
   }
 
-  const props = ["allOf", "oneOf", "anyOf"] as const;
-  for (const prop of props) {
+  for (const prop of COMPOSITE_KEYWORDS) {
     if (schema[prop]) {
       for (const item of schema[prop]!) {
         visit({ ...params, schema: item });
       }
     }
   }
-  if (props.some((prop) => schema[prop])) {
+  if (COMPOSITE_KEYWORDS.some((prop) => schema[prop])) {
     return;
   }
 

src/generators/utils/js.utils.ts

@@ -1,41 +1,3 @@
-export const RESERVED_WORDS = [
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "import",
-  "in",
-  "instanceof",
-  "new",
-  "null",
-  "return",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-];
-
 export const isValidPropertyName = (str: string) => /^(?:[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+)$/.test(str);
 
 export const invalidVariableNameCharactersToCamel = (str: string) =>

src/generators/utils/openapi.utils.ts

@@ -1,9 +1,9 @@
 import { OpenAPIV3 } from "openapi-types";
 import { match, P } from "ts-pattern";
+import { RESERVED_WORDS } from "../const/js.const";
 import { ALLOWED_METHODS, ALLOWED_PARAM_MEDIA_TYPES, PRIMITIVE_TYPE_LIST } from "../const/openapi.const";
 import { PrimitiveType, SingleType } from "../types/openapi";
 import { GenerateOptions } from "../types/options";
-import { RESERVED_WORDS } from "./js.utils";
 import { pick } from "./object.utils";
 import { capitalize, kebabToCamel, nonWordCharactersToCamel, snakeToCamel } from "./string.utils";
 

src/generators/utils/ts.utils.ts

@@ -1,5 +1,6 @@
 import { OpenAPIV3 } from "openapi-types";
 import { match } from "ts-pattern";
+import { COMPOSITE_KEYWORDS } from "../const/openapi.const";
 import { SchemaResolver } from "../core/SchemaResolver.class";
 import { GenerateType } from "../types/generate";
 import { TsMetaType, TsObjectMetaType, TsProperty, TsType, TsTypeBase } from "../types/metadata";
@@ -64,8 +65,7 @@ export function getSchemaTsMetaType({
     return { metaType: "primitive" };
   }
 
-  const compositeKeywords = ["allOf", "anyOf", "oneOf"] as (keyof OpenAPIV3.SchemaObject)[];
-  for (const compositeKeyword of compositeKeywords) {
+  for (const compositeKeyword of COMPOSITE_KEYWORDS) {
     const compositeObjs = schema[compositeKeyword] as (OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject)[];
     if (!compositeObjs) {
       continue;