fix: add a separate mapper for method

Author: CountRedClaw

src/openapi/openapi3.classify.ts

@@ -14,7 +14,7 @@ import { getKeyValue, isExist, isNotEmptyArray } from '../utils'
 import { emptySecurity, includeSecurity } from './openapi3.utils'
 import type { ClassifyRule, CompareContext } from '../types'
 import { DiffType } from '../types'
-import { unifyPath } from './openapi3.mapping'
+import { createPathUnifier } from './openapi3.mapping'
 
 export const paramClassifyRule: ClassifyRule = [
   ({ after }) => {
@@ -143,8 +143,8 @@ export const pathChangeClassifyRule: ClassifyRule = [
   ({ before, after }) => {
     const beforePath = before.key as string
     const afterPath = after.key as string
-    const unifiedBeforePath = unifyPath(before)(beforePath)
-    const unifiedAfterPath = unifyPath(after)(afterPath)
+    const unifiedBeforePath = createPathUnifier(before)(beforePath)
+    const unifiedAfterPath = createPathUnifier(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,5 +1,5 @@
 import { MapKeysResult, MappingResolver, NodeContext } from '../types'
-import { getStringValue, objectKeys, onlyExistedArrayIndexes } from '../utils'
+import { difference, getStringValue, intersection, objectKeys, onlyExistedArrayIndexes } from '../utils'
 import { mapPathParams } from './openapi3.utils'
 import { OpenAPIV3 } from 'openapi-types'
 
@@ -28,28 +28,33 @@ 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(unifyPath(ctx.after))
+  const unifiedBeforeKeyToKey = Object.fromEntries(objectKeys(before).map(key => [createPathUnifier(ctx.before)(key), key]))
+  const unifiedAfterKeyToKey = Object.fromEntries(objectKeys(after).map(key => [createPathUnifier(ctx.after)(key), key]))
 
-  const notMappedAfterIndices = new Set(originalAfterKeys.keys())
+  const unifiedBeforeKeys = Object.keys(unifiedBeforeKeyToKey)
+  const unifiedAfterKeys = Object.keys(unifiedAfterKeyToKey)
 
-  originalBeforeKeys.forEach(beforeKey => {
-    const unifiedBeforePath = unifyPath(ctx.before)(beforeKey)
-    const index = unifiedAfterKeys.indexOf(unifiedBeforePath)
+  result.added = difference(unifiedAfterKeys, unifiedBeforeKeys).map(key => unifiedAfterKeyToKey[key])
+  result.removed = difference(unifiedBeforeKeys, unifiedAfterKeys).map(key => unifiedBeforeKeyToKey[key])
+  result.mapped = Object.fromEntries(
+    intersection(unifiedBeforeKeys, unifiedAfterKeys).map(key => [unifiedBeforeKeyToKey[key], unifiedAfterKeyToKey[key]]),
+  )
 
-    if (index < 0) {
-      // removed item
-      result.removed.push(beforeKey)
-    } else {
-      // mapped items
-      result.mapped[beforeKey] = originalAfterKeys[index]
-      notMappedAfterIndices.delete(index)
-    }
-  })
+  return result
+}
+
+export const methodMappingResolver: MappingResolver<string> = (before, after) => {
+
+  const result: MapKeysResult<string> = { added: [], removed: [], mapped: {} }
+
+  const beforeKeys = objectKeys(before)
+  const afterKeys = objectKeys(after)
+
+  result.added = difference(afterKeys, beforeKeys)
+  result.removed = difference(beforeKeys, afterKeys)
 
-  // added items
-  notMappedAfterIndices.forEach((notMappedIndex) => result.added.push(originalAfterKeys[notMappedIndex]))
+  const mapped = intersection(beforeKeys, afterKeys)
+  mapped.forEach(key => result.mapped[key] = key)
 
   return result
 }
@@ -196,7 +201,7 @@ export const extractOperationBasePath = (servers?: OpenAPIV3.ServerObject[]): st
   }
 }
 
-export function unifyPath(nodeContext: NodeContext): (path: string) => string {
+export function createPathUnifier(nodeContext: NodeContext): (path: string) => string {
   const serverPrefix = extractOperationBasePath((nodeContext.root as OpenAPIV3.Document).servers) // /api/v2
   return (path) => (
     serverPrefix

src/openapi/openapi3.rules.ts

@@ -55,6 +55,7 @@ import {
 } from './openapi3.classify'
 import {
   contentMediaTypeMappingResolver,
+  methodMappingResolver,
   paramMappingResolver,
   pathMappingResolver,
   singleOperationPathMappingResolver,
@@ -392,7 +393,7 @@ export const openApi3Rules = (options: OpenApi3RulesOptions): CompareRules => {
 
   const pathItemObjectRules = (options: OpenApi3RulesOptions): CompareRules => ({
     $: pathChangeClassifyRule,
-    mapping: options.mode === COMPARE_MODE_OPERATION ? singleOperationPathMappingResolver : pathMappingResolver,
+    mapping: options.mode === COMPARE_MODE_OPERATION ? singleOperationPathMappingResolver : methodMappingResolver,
     '/description': { $: allAnnotation },
     '/parameters': {
       $: [nonBreaking, breaking, breaking],

src/utils.ts

@@ -221,3 +221,13 @@ export const checkPrimitiveType = (value: unknown): PrimitiveType | undefined =>
   }
   return undefined
 }
+
+export function intersection(array1: string[], array2: string[]): string[] {
+  const set2 = new Set(array2)
+  return [...new Set(array1.filter(x => set2.has(x)))]
+}
+
+export function difference(array1: string[], array2: string[]): string[] {
+  const set2 = new Set(array2)
+  return [...new Set(array1.filter(x => !set2.has(x)))]
+}