feat: path change due to moving a prefix from server.url to path classified as annotation

Author: CountRedClaw

src/openapi/openapi3.classify.ts

@@ -5,16 +5,16 @@ import {
   breakingIfAfterTrue,
   nonBreaking,
   PARENT_JUMP,
-  strictResolveValueFromContext,
   reverseClassifyRule,
+  strictResolveValueFromContext,
   transformClassifyRule,
   unclassified,
 } from '../core'
 import { getKeyValue, isExist, isNotEmptyArray } from '../utils'
 import { emptySecurity, includeSecurity } from './openapi3.utils'
 import type { ClassifyRule, CompareContext } from '../types'
 import { DiffType } from '../types'
-import { hidePathParamNames } from './openapi3.mapping'
+import { unifyPath } from './openapi3.mapping'
 
 export const paramClassifyRule: ClassifyRule = [
   ({ after }) => {
@@ -143,9 +143,9 @@ export const pathChangeClassifyRule: ClassifyRule = [
   ({ before, after }) => {
     const beforePath = before.key as string
     const afterPath = after.key as string
-    const unifiedBeforePath = hidePathParamNames(beforePath)
-    const unifiedAfterPath = hidePathParamNames(afterPath)
-    
+    const unifiedBeforePath = unifyPath(before)(beforePath)
+    const unifiedAfterPath = unifyPath(after)(afterPath)
+
     // If unified paths are the same, it means only parameter names changed
     return unifiedBeforePath === unifiedAfterPath ? annotation : breaking
   }

src/openapi/openapi3.mapping.ts

@@ -1,6 +1,7 @@
-import type { MapKeysResult, MappingResolver } from '../types'
+import { MapKeysResult, MappingResolver, NodeContext } from '../types'
 import { getStringValue, objectKeys, onlyExistedArrayIndexes } from '../utils'
 import { mapPathParams } from './openapi3.utils'
+import { OpenAPIV3 } from 'openapi-types'
 
 export const singleOperationPathMappingResolver: MappingResolver<string> = (before, after) => {
 
@@ -23,18 +24,18 @@ export const singleOperationPathMappingResolver: MappingResolver<string> = (befo
   return result
 }
 
-export const pathMappingResolver: MappingResolver<string> = (before, after) => {
+export const pathMappingResolver: MappingResolver<string> = (before, after, ctx) => {
 
   const result: MapKeysResult<string> = { added: [], removed: [], mapped: {} }
 
   const originalBeforeKeys = objectKeys(before)
   const originalAfterKeys = objectKeys(after)
-  const unifiedAfterKeys = originalAfterKeys.map(hidePathParamNames)
+  const unifiedAfterKeys = originalAfterKeys.map(unifyPath(ctx.after))
 
   const notMappedAfterIndices = new Set(originalAfterKeys.keys())
 
   originalBeforeKeys.forEach(beforeKey => {
-    const unifiedBeforePath = hidePathParamNames(beforeKey)
+    const unifiedBeforePath = unifyPath(ctx.before)(beforeKey)
     const index = unifiedAfterKeys.indexOf(unifiedBeforePath)
 
     if (index < 0) {
@@ -175,6 +176,35 @@ function isWildcardCompatible(beforeType: string, afterType: string): boolean {
   return true
 }
 
+// todo copy-paste from api-processor
+export const extractOperationBasePath = (servers?: OpenAPIV3.ServerObject[]): string => {
+  if (!Array.isArray(servers) || !servers.length) { return '' }
+
+  try {
+    const [firstServer] = servers
+    let serverUrl = firstServer.url
+    const { variables = {} } = firstServer
+
+    for (const param of Object.keys(variables)) {
+      serverUrl = serverUrl.replace(new RegExp(`{${param}}`, 'g'), variables[param].default)
+    }
+
+    const { pathname } = new URL(serverUrl, 'https://localhost')
+    return pathname.slice(-1) === '/' ? pathname.slice(0, -1) : pathname
+  } catch (error) {
+    return ''
+  }
+}
+
+export function unifyPath(nodeContext: NodeContext): (path: string) => string {
+  const serverPrefix = extractOperationBasePath((nodeContext.root as OpenAPIV3.Document).servers) // /api/v2
+  return (path) => (
+    serverPrefix
+      ? `${serverPrefix}${hidePathParamNames(path)}`
+      : hidePathParamNames(path)
+  )
+}
+
 export function hidePathParamNames(path: string): string {
   return path.replace(PATH_PARAMETER_REGEXP, PATH_PARAM_UNIFIED_PLACEHOLDER)
 }