feat: support prefix groups comparison

CountRedClaw · CountRedClaw · commit e820f6be7809 · 2025-08-25T19:44:53.000+05:00
diff --git a/src/apitypes/rest/rest.changes.ts b/src/apitypes/rest/rest.changes.ts
@@ -20,6 +20,7 @@ import {
   IGNORE_PATH_PARAM_UNIFIED_PLACEHOLDER,
   isEmpty,
   isOperationRemove,
+  isPathParamRenameDiff,
   normalizePath,
   removeComponents,
   removeFirstSlash,
@@ -60,7 +61,7 @@ import { calculateObjectHash } from '../../utils/hashes'
 import { REST_API_TYPE } from './rest.consts'
 import { OpenAPIV3 } from 'openapi-types'
 import { extractServersDiffs, getOperationBasePath } from './rest.utils'
-import { createOperationChange, getOperationTags, takeSubstringIf } from '../../components'
+import { createOperationChange, getOperationTags } from '../../components'
 
 export const compareDocuments = async (apiType: OperationsApiType, operationsMap: Record<NormalizedOperationId, {
   previous?: ResolvedOperation
@@ -69,17 +70,29 @@ export const compareDocuments = async (apiType: OperationsApiType, operationsMap
   operationChanges: OperationChanges[]
   tags: string[]
 }> => {
-  const { rawDocumentResolver, previousVersion, currentVersion, previousPackageId, currentPackageId } = ctx
+  const { rawDocumentResolver, previousVersion, currentVersion, previousPackageId, currentPackageId, currentGroup, previousGroup } = ctx
   const prevFile = prevDoc && await rawDocumentResolver(previousVersion, previousPackageId, prevDoc.slug)
   const currFile = currDoc && await rawDocumentResolver(currentVersion, currentPackageId, currDoc.slug)
   let prevDocData = prevFile && JSON.parse(await prevFile.text())
   let currDocData = currFile && JSON.parse(await currFile.text())
 
+  const isChangedOperations = prevDoc && currDoc
+
+  if (prevDocData && previousGroup) {
+    // todo what's with components? why don't remove?
+    prevDocData = createCopyWithCurrentGroupOperationsOnly(prevDocData, previousGroup)
+  }
+
+  if (currDocData && currentGroup) {
+    // todo what's with components? why don't remove?
+    currDocData = createCopyWithCurrentGroupOperationsOnly(currDocData, currentGroup)
+  }
+
   if (!prevDocData && currDocData) {
-    prevDocData = createCopyWithEmptyPath(currDocData)
+    prevDocData = createCopyWithEmptyPathItems(currDocData)
   }
   if (prevDocData && !currDocData) {
-    currDocData = createCopyWithEmptyPath(prevDocData)
+    currDocData = createCopyWithEmptyPathItems(prevDocData)
   }
 
   const { merged, diffs } = apiDiff(
@@ -99,13 +112,6 @@ export const compareDocuments = async (apiType: OperationsApiType, operationsMap
     return { operationChanges: [], tags: [] }
   }
 
-  // todo reclassify
-  // const olnyBreaking = diffs.filter((diff) => diff.type === breaking)
-  // if (olnyBreaking.length > 0 && previous?.operationId) {
-  //   await reclassifyBreakingChanges(previous.operationId, diffResult.merged, olnyBreaking, ctx)
-  // }
-
-  const { currentGroup, previousGroup } = ctx.config
   const currGroupSlug = slugify(removeFirstSlash(currentGroup || ''))
   const prevGroupSlug = slugify(removeFirstSlash(previousGroup || ''))
 
@@ -127,40 +133,47 @@ export const compareDocuments = async (apiType: OperationsApiType, operationsMap
       const methodData = pathData[inferredMethod]
       const basePath = getOperationBasePath(methodData?.servers || pathData?.servers || merged.servers || [])
       const operationPath = basePath + path
-      const operationId = slugify(`${removeFirstSlash(operationPath)}-${inferredMethod}`)
+      const operationId = slugify(`${operationPath}-${inferredMethod}`)
       const normalizedOperationId = slugify(`${normalizePath(basePath + path)}-${inferredMethod}`, [], IGNORE_PATH_PARAM_UNIFIED_PLACEHOLDER)
-      // todo what's with prevslug? which tests affected? which slug to slice prev or curr?
-      const qwe = takeSubstringIf(!!currGroupSlug, normalizedOperationId, currGroupSlug.length)
 
-      const { current, previous } = operationsMap[qwe] ?? operationsMap[operationId] ?? {}
+      const { current, previous } = operationsMap[normalizedOperationId] ?? operationsMap[operationId] ?? {}
 
       let operationDiffs: Diff[] = []
-      if (current && previous) {
+      if (current && previous && isChangedOperations) {
         operationDiffs = [
           ...(methodData as WithAggregatedDiffs<OpenAPIV3.OperationObject>)[DIFFS_AGGREGATED_META_KEY],
           // todo what about security? add test
           ...extractServersDiffs(merged),
         ]
 
-        const pathParamRenameDiff = (merged.paths as WithDiffMetaRecord<OpenAPIV3.PathsObject>)[DIFF_META_KEY]?.[path]
-        pathParamRenameDiff && operationDiffs.push(pathParamRenameDiff)
-      } else if (current || previous) {
+        const diff = (merged.paths as WithDiffMetaRecord<OpenAPIV3.PathsObject>)[DIFF_META_KEY]?.[path]
+        if (diff && isPathParamRenameDiff(diff)) {
+          // ignore removed and added operations, they'll be handled in a separate docs comparison???
+          operationDiffs.push(diff)
+        }
+      }
+      if ((!!current !== !!previous) && !isChangedOperations) {
         const operationDiff = (merged.paths[path] as WithDiffMetaRecord<OpenAPIV3.PathsObject>)[DIFF_META_KEY]?.[inferredMethod]
         if (!operationDiff) {
           // ignore removed and added operations, they'll be handled in a separate docs comparison
           continue
         }
-        const deprecatedInVersionsCount = previousVersionDeprecations?.operations.find((operation) => operation.operationId === operationId)?.deprecatedInPreviousVersions?.length ?? 0
-        if (isOperationRemove(operationDiff) && deprecatedInVersionsCount > 1) {
-          operationDiff.type = risky
-        }
+        // const deprecatedInVersionsCount = previousVersionDeprecations?.operations.find((operation) => operation.operationId === operationId)?.deprecatedInPreviousVersions?.length ?? 0
+        // if (isOperationRemove(operationDiff) && deprecatedInVersionsCount > 1) {
+        //   operationDiff.type = risky
+        // }
         operationDiffs.push(operationDiff)
       }
 
       if (isEmpty(operationDiffs)) {
         continue
       }
 
+      const onlyBreaking = operationDiffs.filter((diff) => diff.type === breaking)
+      if (onlyBreaking.length > 0 && previous?.operationId) {
+        await reclassifyBreakingChanges(previous.operationId, merged, onlyBreaking, ctx)
+      }
+
       // todo operationDiffs can be [undefined] in 'type error must not appear during build'
       changedOperations.push(createOperationChange(apiType, operationDiffs, previous, current, currGroupSlug, prevGroupSlug, currentGroup, previousGroup))
       getOperationTags(current ?? previous).forEach(tag => tags.add(tag))
@@ -176,11 +189,11 @@ export const compareRestOperationsData = async (current: VersionRestOperation |
   let previousOperation = removeComponents(previous?.data)
   let currentOperation = removeComponents(current?.data)
   if (!previousOperation && currentOperation) {
-    previousOperation = createCopyWithEmptyPath(currentOperation as RestOperationData)
+    previousOperation = createCopyWithEmptyPathItems(currentOperation as RestOperationData)
   }
 
   if (previousOperation && !currentOperation) {
-    currentOperation = createCopyWithEmptyPath(previousOperation as RestOperationData)
+    currentOperation = createCopyWithEmptyPathItems(previousOperation as RestOperationData)
   }
 
   const diffResult = apiDiff(
@@ -285,13 +298,30 @@ async function reclassifyBreakingChanges(
   }
 }
 
-export function createCopyWithEmptyPath(template: RestOperationData): RestOperationData {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function createCopyWithEmptyPathItems(template: RestOperationData): RestOperationData {
+  const { paths, ...rest } = template
+
+  return {
+    paths: {
+      ...Object.fromEntries(Object.keys(paths).map(key => [key, {}])),
+    },
+    ...rest,
+  }
+}
+
+export function createCopyWithCurrentGroupOperationsOnly(template: RestOperationData, group: string): RestOperationData {
   const { paths, ...rest } = template
+  const groupWithoutLeadingSlash = removeFirstSlash(group)
 
   return {
     paths: {
-      ...Object.fromEntries(Object.keys(template.paths).map(key => [key, {}])),
+      ...Object.fromEntries(
+        Object.entries(paths)
+          .filter(([key]) => removeFirstSlash(key).startsWith(groupWithoutLeadingSlash))
+          // remove prefix group for correct path mapping in apiDiff
+          // todo support the most common case when a group is in servers instead of hardcoded in path, add a test
+          .map(([key, value]) => [removeFirstSlash(key).substring(groupWithoutLeadingSlash.length), value]),
+      ),
     },
     ...rest,
   }
diff --git a/src/components/compare/compare.operations.ts b/src/components/compare/compare.operations.ts
@@ -29,13 +29,15 @@ import {
 import {
   calculateTotalImpactedSummary,
   createPairOperationsMap,
+  dedupePairs,
   getUniqueApiTypesFromVersions,
   normalizeOperationIds,
 } from './compare.utils'
 import {
   calculateApiAudienceTransitions,
   calculateChangeSummary,
   calculateDiffId,
+  convertToSlug,
   difference,
   executeInBatches,
   getSplittedVersionKey,
@@ -106,20 +108,31 @@ async function compareCurrentApiType(
   ctx: CompareContext,
   debugCtx?: DebugPerformanceContext,
 ): Promise<[OperationType, OperationChanges[]] | null> {
-  const { batchSize, versionOperationsResolver, versionDocumentsResolver, rawDocumentResolver } = ctx
-
+  const {
+    batchSize,
+    versionOperationsResolver,
+    versionDocumentsResolver,
+    rawDocumentResolver,
+    config: { currentGroup = '', previousGroup = '' },
+  } = ctx
   const apiBuilder = ctx.apiBuilders.find((builder) => apiType === builder.apiType)
   if (!apiBuilder) { return null }
 
   const { operations: prevOperations = [] } = await versionOperationsResolver(apiType, prev?.version ?? '', prev?.packageId ?? '', undefined, false) || {}
   const { operations: currOperations = [] } = await versionOperationsResolver(apiType, curr?.version ?? '', curr?.packageId ?? '', undefined, false) || {}
 
-  const [prevOperationIds, prevNormalizedOperationIdToOperation] = normalizeOperationIds(prevOperations, apiBuilder)
-  const [currOperationIds, currNormalizedOperationIdToOperation] = normalizeOperationIds(currOperations, apiBuilder)
+  const previousGroupSlug = convertToSlug(previousGroup)
+  const prevOperationsWithPrefix = previousGroupSlug ? prevOperations.filter(operation => operation.operationId.startsWith(previousGroupSlug)) : prevOperations
+
+  const currentGroupSlug = convertToSlug(currentGroup)
+  const currOperationsWithPrefix = currentGroupSlug ? currOperations.filter(operation => operation.operationId.startsWith(currentGroupSlug)) : currOperations
 
-  const added = difference(currOperationIds, prevOperationIds)
-  const removed = difference(prevOperationIds, currOperationIds)
-  const rest = intersection(prevOperationIds, currOperationIds)
+  const [prevNormalizedOperationIds, prevNormalizedOperationIdToOperation] = normalizeOperationIds(prevOperationsWithPrefix, apiBuilder, previousGroup)
+  const [currNormalizedOperationIds, currNormalizedOperationIdToOperation] = normalizeOperationIds(currOperationsWithPrefix, apiBuilder, currentGroup)
+
+  const added = difference(currNormalizedOperationIds, prevNormalizedOperationIds)
+  const removed = difference(prevNormalizedOperationIds, currNormalizedOperationIds)
+  const potentiallyChanged = intersection(prevNormalizedOperationIds, currNormalizedOperationIds)
 
   const { version: prevVersion, packageId: prevPackageId } = prev ?? { version: '', packageId: '' }
   const { version: currVersion, packageId: currPackageId } = curr ?? { version: '', packageId: '' }
@@ -131,7 +144,7 @@ async function compareCurrentApiType(
   const currDocuments = unfilteredCurrDocuments
 
   const pairedRestDocs: [ResolvedVersionDocument, ResolvedVersionDocument][] = []
-  for (const normalizedOperationId of rest) {
+  for (const normalizedOperationId of potentiallyChanged) {
     const prevDocumentId = prevNormalizedOperationIdToOperation[normalizedOperationId]?.documentId
     const currDocumentId = currNormalizedOperationIdToOperation[normalizedOperationId]?.documentId
     const prevDoc = prevDocuments.find(document => document.slug === prevDocumentId)
@@ -161,31 +174,27 @@ async function compareCurrentApiType(
     pairedDocs.push([prevDoc, undefined])
   }
 
-  // todo > 1 is a hack for before\after files naming, docs matching approach is not yet defined
-  // const pairedDocs = prevDocuments.map((prevDoc) => [prevDoc, currDocuments.length > 1 ? currDocuments.find(({ fileId }) => fileId === prevDoc.fileId) : currDocuments[0]])
-
-  const { currentGroup, previousGroup } = ctx.config
   const currGroupSlug = slugify(removeFirstSlash(currentGroup || ''))
   const prevGroupSlug = slugify(removeFirstSlash(previousGroup || ''))
 
-  const operationsMap = createPairOperationsMap(currGroupSlug, prevGroupSlug, currOperations, prevOperations, apiBuilder)
+  const operationsMap = createPairOperationsMap(prevGroupSlug, currGroupSlug, prevOperationsWithPrefix, currOperationsWithPrefix, apiBuilder)
 
   const operationChanges: OperationChanges[] = []
   const tags: string[] = []
 
-  for (const [prevDoc, currDoc] of pairedDocs) {
-    const pairContext: CompareOperationsPairContext = {
-      notifications: ctx.notifications,
-      rawDocumentResolver,
-      versionDeprecatedResolver: ctx.versionDeprecatedResolver,
-      previousVersion: prevVersion,
-      currentVersion: currVersion,
-      previousPackageId: prevPackageId,
-      currentPackageId: currPackageId,
-      currentGroup: currentGroup,
-      previousGroup: previousGroup,
-    }
+  const pairContext: CompareOperationsPairContext = {
+    notifications: ctx.notifications,
+    rawDocumentResolver,
+    versionDeprecatedResolver: ctx.versionDeprecatedResolver,
+    previousVersion: prevVersion,
+    currentVersion: currVersion,
+    previousPackageId: prevPackageId,
+    currentPackageId: currPackageId,
+    currentGroup: currentGroup,
+    previousGroup: previousGroup,
+  }
 
+  for (const [prevDoc, currDoc] of pairedDocs) {
     const {
       operationChanges: docsPairOperationChanges,
       tags: docsPairTags,
@@ -214,7 +223,7 @@ async function compareCurrentApiType(
     const { operations: currOperationsWithoutData = [] } = await versionOperationsResolver(apiType, currVersion, currPackageId, previousBatch, false) || {}
     const { operations: prevOperationsWithoutData = [] } = await versionOperationsResolver(apiType, prevVersion, prevPackageId, currentBatch, false) || {}
 
-    const pairOperationsMap = createPairOperationsMap(currGroupSlug, prevGroupSlug, currOperationsWithoutData, prevOperationsWithoutData, apiBuilder)
+    const pairOperationsMap = createPairOperationsMap(prevGroupSlug, currGroupSlug, prevOperationsWithoutData, currOperationsWithoutData, apiBuilder)
     Object.values(pairOperationsMap).forEach((pair) => {
       calculateApiAudienceTransitions(pair.current, pair.previous, apiAudienceTransitions)
     })
diff --git a/src/components/compare/compare.utils.ts b/src/components/compare/compare.utils.ts
@@ -117,12 +117,13 @@ export function dedupePairs<A extends object, B extends object>(
   return out
 }
 
-export function normalizeOperationIds(operations: ResolvedOperation[], apiBuilder: ApiBuilder): [OperationId[], Record<NormalizedOperationId | OperationId, ResolvedOperation>] {
+export function normalizeOperationIds(operations: ResolvedOperation[], apiBuilder: ApiBuilder, group: string): [OperationId[], Record<NormalizedOperationId | OperationId, ResolvedOperation>] {
   const normalizedOperationIdToOperation: Record<NormalizedOperationId | OperationId, ResolvedOperation> = {}
-  for (const operation of operations) {
+  const groupSlug = convertToSlug(group)
+  operations.forEach(operation => {
     const normalizedOperationId = apiBuilder.createNormalizedOperationId?.(operation) ?? operation.operationId
-    normalizedOperationIdToOperation[normalizedOperationId] = operation
-  }
+    normalizedOperationIdToOperation[takeSubstringIf(!!groupSlug, normalizedOperationId, groupSlug.length)] = operation
+  })
   return [Object.keys(normalizedOperationIdToOperation), normalizedOperationIdToOperation]
 }
 
@@ -193,10 +194,10 @@ export function takeSubstringIf(condition: boolean, value: string, startIndex: n
 }
 
 export const createPairOperationsMap = (
-  currGroupSlug: string,
   prevGroupSlug: string,
-  currentOperations: ResolvedOperation[],
+  currGroupSlug: string,
   previousOperations: ResolvedOperation[],
+  currentOperations: ResolvedOperation[],
   apiBuilder: ApiBuilder,
 ): Record<NormalizedOperationId, {
   previous?: ResolvedOperation
@@ -210,12 +211,12 @@ export const createPairOperationsMap = (
 
   for (const currentOperation of currentOperations) {
     const normalizedOperationId = apiBuilder.createNormalizedOperationId?.(currentOperation) ?? currentOperation.operationId
-    operationsMap[takeSubstringIf(!!currGroupSlug, normalizedOperationId, currGroupSlug.length)] = { current: currentOperation }
+    operationsMap[takeSubstringIf(!!currGroupSlug, normalizedOperationId, currGroupSlug.length + '-'.length)] = { current: currentOperation }
   }
 
   for (const previousOperation of previousOperations) {
     const normalizedOperationId = apiBuilder.createNormalizedOperationId?.(previousOperation) ?? previousOperation.operationId
-    const prevOperationId = takeSubstringIf(!!prevGroupSlug, normalizedOperationId, prevGroupSlug.length)
+    const prevOperationId = takeSubstringIf(!!prevGroupSlug, normalizedOperationId, prevGroupSlug.length + '-'.length)
     // todo it won't work if groups have different length (add test with /api/v1/ and /api/abc/)
     const operationsMappingElement = operationsMap[prevOperationId]
     operationsMap[prevOperationId] = {
diff --git a/src/types/external/config.ts b/src/types/external/config.ts
@@ -156,8 +156,6 @@ export interface PrefixGroupsChangelogBuildConfig extends BuildConfigBase {
   packageId: PackageId
   version: VersionId
   status: VersionStatus
-  previousVersion?: VersionId
-  previousVersionPackageId?: PackageId
   currentGroup?: string
   previousGroup?: string
 
diff --git a/src/utils/operations.utils.ts b/src/utils/operations.utils.ts
@@ -82,3 +82,7 @@ export function isOperationRemove(operationDiff: Diff): boolean {
   // length is 2 because json path has view like ['paths', '/test/element']
   return operationDiff.action === DiffAction.remove && !!matchPaths(operationDiff.beforeDeclarationPaths, [[OPEN_API_PROPERTY_PATHS, PREDICATE_ANY_VALUE, PREDICATE_ANY_VALUE]])
 }
+
+export function isPathParamRenameDiff(diff: Diff): boolean {
+  return diff.action === DiffAction.rename && !!matchPaths(diff.beforeDeclarationPaths, [[OPEN_API_PROPERTY_PATHS, PREDICATE_ANY_VALUE]])
+}

Original file line number	Diff line number	Diff line change
`@@ -82,3 +82,7 @@ export function isOperationRemove(operationDiff: Diff): boolean {`
`82`	`82`	`// length is 2 because json path has view like ['paths', '/test/element']`
`83`	`83`	`return operationDiff.action === DiffAction.remove && !!matchPaths(operationDiff.beforeDeclarationPaths, [[OPEN_API_PROPERTY_PATHS, PREDICATE_ANY_VALUE, PREDICATE_ANY_VALUE]])`
`84`	`84`	`}`
	`85`	`+`
	`86`	`+export function isPathParamRenameDiff(diff: Diff): boolean {`
	`87`	`+ return diff.action === DiffAction.rename && !!matchPaths(diff.beforeDeclarationPaths, [[OPEN_API_PROPERTY_PATHS, PREDICATE_ANY_VALUE]])`
	`88`	`+}`