feat: Refactoring

Author: makeev-pavel

src/apitypes/rest/rest.operation.ts

@@ -36,6 +36,7 @@ import {
   isOperationDeprecated,
   normalizePath,
   rawToApiKind,
+  resolveRefAndMap,
   setValueByPath,
   takeIf,
   takeIfDefined,
@@ -213,7 +214,7 @@ export const calculateSpecRefs = (sourceDocument: unknown, normalizedSpec: unkno
     }
     //todo why? description?
     const componentName = matchResult.grepValues[grepKey].toString()
-    const sourceComponents = getKeyValue(sourceDocument, ...matchResult.path)
+    let sourceComponents = getKeyValue(sourceDocument, ...matchResult.path)
     const resultComponents = getKeyValue(resultSpec, ...matchResult.path)
     const httpMethods = new Set<string>(Object.values(OpenAPIV3.HttpMethods) as string[])
     const allowedOps = (typeof resultComponents === 'object' && resultComponents !== null)
@@ -223,6 +224,7 @@ export const calculateSpecRefs = (sourceDocument: unknown, normalizedSpec: unkno
       return
     }
     if (allowedOps.length > 0) {
+      sourceComponents = { ...sourceComponents }
       Object.keys(sourceComponents as object).forEach((key: string) => {
         if (httpMethods.has(key) && !allowedOps.includes(key)) {
           // prune operations not present in the partial result component
@@ -238,6 +240,8 @@ export const calculateSpecRefs = (sourceDocument: unknown, normalizedSpec: unkno
       if (componentHash) {
         models[componentName] = componentHash
       } else {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
         componentHash = calculateObjectHash(sourceComponents)
         componentsHashMap?.set(componentName, componentHash)
         models[componentName] = componentHash
@@ -274,8 +278,12 @@ const createSingleOperationSpec = (
 ): TYPE.RestOperationData => {
   const pathData = document.paths[path] as OpenAPIV3.PathItemObject
 
-  if (INLINE_REFS_FLAG in pathData || (pathData && '$ref' in pathData && pathData.$ref)) {
-    //todo check
+  const ref = pathData?.$ref
+  if (pathData && ref) {
+    const cleanedDocument = resolveRefAndMap(document, ref, (pathItemObject: OpenAPIV3.PathItemObject) => ({
+      ...extractCommonPathItemProperties(pathItemObject),
+      [method]: { ...pathItemObject[method] },
+    }))
     return {
       openapi: openapi ?? '3.0.0',
       ...takeIfDefined({ servers }),
@@ -285,6 +293,7 @@ const createSingleOperationSpec = (
       },
       components: {
         ...takeIfDefined({ securitySchemes }),
+        ...cleanedDocument?.components ?? {},
       },
     }
   }

src/strategies/document-group.strategy.ts

@@ -154,17 +154,19 @@ function transformDocumentData(versionDocument: VersionDocument): OpenAPIV3.Docu
       const pathData = sourceDocument.paths[path]!
       if (pathItemRef) {
         const targetFromResultDocument = getParentValueByRef(resultDocument, pathData.$ref ?? '')
-        const target = resolveRefAndMap(sourceDocument, pathData.$ref ?? '', (value) => ({
+        const target = resolveRefAndMap(sourceDocument, pathData.$ref ?? '', (pathItemObject: OpenAPIV3.PathItemObject) => ({
           ...targetFromResultDocument,
-          ...extractCommonPathItemProperties(value),
-          [method]: { ...value[method] },
+          ...extractCommonPathItemProperties(pathItemObject),
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          [method]: { ...pathItemObject[method] },
         }))
 
         resultDocument.paths[path] = pathData
 
         resultDocument.components = {
           ...takeIfDefined({ securitySchemes: sourceComponents?.securitySchemes }),
-          ...target.components,
+          ...target.components ?? {},
         }
       } else {
         const existingPath = resultDocument.paths[path]

src/utils/builder.ts

@@ -30,6 +30,7 @@ import { API_KIND } from '../consts'
 import { Diff, DiffType } from '@netcracker/qubership-apihub-api-diff'
 import { JsonPath } from '@netcracker/qubership-apihub-json-crawl'
 import { parseRef } from '@netcracker/qubership-apihub-api-unifier'
+import { OpenAPIV3 } from 'openapi-types'
 
 export type ObjPath = (string | number)[]
 
@@ -217,44 +218,51 @@ export const getParentValueByRef = (obj: any, ref: string): any => {
 }
 
 export const resolveRefAndMap = (
-  obj: any,
+  document: OpenAPIV3.Document,
   ref: string,
-  valueMapper: (target: any) => any,
-  component: any = {},
-): any => {
-  const visited = new Set<string>()
+  valueMapper: (target: Record<string, unknown>) => Record<string, unknown>,
+  result: Record<string, unknown> = {},
+): Record<string, unknown> => {
+  const cyclingGuard = new Set<string>()
   let currentRef: string | undefined = ref
   let lastPath: JsonPath = []
 
   while (currentRef) {
-    if (visited.has(currentRef)) {
-      // circular reference guard
+    if (cyclingGuard.has(currentRef)) {
       break
     }
-    visited.add(currentRef)
+    cyclingGuard.add(currentRef)
 
     const { jsonPath } = parseRef(currentRef)
     lastPath = jsonPath
-    const value = getValueByJsonPath(obj, jsonPath)
+
+    const rawValue = getValueByJsonPath(document, jsonPath)
+    if (rawValue === null) {
+      break
+    }
+
+    const value = { ...rawValue }
 
     if (isRecordObject(value) && typeof value.$ref === 'string') {
       // preserve intermediate referenced node
-      setValueByPath(component, jsonPath, value)
+      setValueByPath(result, jsonPath, value)
       currentRef = value.$ref
       continue
     }
 
     // terminal value reached; apply mapper
-    setValueByPath(component, jsonPath, valueMapper(value))
-    return component
+    setValueByPath(result, jsonPath, valueMapper(value))
+    return result
   }
 
   // Fallback when loop breaks due to cycle or missing ref
   if (lastPath.length) {
-    const terminal = getValueByJsonPath(obj, lastPath)
-    setValueByPath(component, lastPath, valueMapper(terminal))
+    const terminal = getValueByJsonPath(document, lastPath)
+    if (terminal !== undefined) {
+      setValueByPath(result, lastPath, valueMapper(terminal))
+    }
   }
-  return component
+  return result
 }
 
 export const rawToApiKind = (apiKindLike: string): ApiKind => {