refactor: move normalized id creation to apiBuilder method

Author: CountRedClaw

src/apitypes/rest/index.ts

@@ -19,7 +19,7 @@ import { OpenAPIV3 } from 'openapi-types'
 import { buildRestDocument, dumpRestDocument } from './rest.document'
 import { REST_API_TYPE, REST_DOCUMENT_TYPE } from './rest.consts'
 import { compareRestOperationsData } from './rest.changes'
-import { buildRestOperations } from './rest.operations'
+import { buildRestOperations, createNormalizedOperationId } from './rest.operations'
 import { parseRestFile } from './rest.parser'
 
 import { ApiBuilder } from '../../types'
@@ -34,4 +34,5 @@ export const restApiBuilder: ApiBuilder<OpenAPIV3.Document> = {
   buildOperations: buildRestOperations,
   dumpDocument: dumpRestDocument,
   compareOperationsData: compareRestOperationsData,
+  createNormalizedOperationId: createNormalizedOperationId,
 }

src/apitypes/rest/rest.operations.ts

@@ -17,8 +17,14 @@
 import { OpenAPIV3 } from 'openapi-types'
 
 import { buildRestOperation } from './rest.operation'
-import { OperationsBuilder } from '../../types'
-import { createBundlingErrorHandler, removeComponents, removeFirstSlash, slugify } from '../../utils'
+import { OperationIdNormalizer, OperationsBuilder } from '../../types'
+import {
+  createBundlingErrorHandler,
+  IGNORE_PATH_PARAM_UNIFIED_PLACEHOLDER,
+  removeComponents,
+  removeFirstSlash,
+  slugify,
+} from '../../utils'
 import { getOperationBasePath } from './rest.utils'
 import type * as TYPE from './rest.types'
 import { HASH_FLAG, INLINE_REFS_FLAG, MESSAGE_SEVERITY, NORMALIZE_OPTIONS, ORIGINS_SYMBOL } from '../../consts'
@@ -106,3 +112,8 @@ export const buildRestOperations: OperationsBuilder<OpenAPIV3.Document> = async
   }
   return operations
 }
+
+export const createNormalizedOperationId: OperationIdNormalizer = (operation) => {
+  const { metadata: { path, method } } = operation
+  return slugify(`${path}-${method}`, [], IGNORE_PATH_PARAM_UNIFIED_PLACEHOLDER)
+}

src/components/compare/compare.operations.ts

@@ -16,6 +16,7 @@
 
 import {
   ApiAudienceTransition,
+  ApiBuilder,
   CompareContext,
   CompareOperationsPairContext,
   OperationChanges,
@@ -33,7 +34,6 @@ import {
   getOperationMetadata,
   getOperationsHashMapByApiType,
   getOperationTags,
-  getOperationTypesFromTwoVersions,
   getUniqueApiTypesFromVersions,
   takeSubstringIf,
   totalChanges,
@@ -45,14 +45,12 @@ import {
   calculateImpactedSummary,
   executeInBatches,
   getSplittedVersionKey,
-  IGNORE_PATH_PARAM_UNIFIED_PLACEHOLDER,
   removeFirstSlash,
   removeObjectDuplicates,
   slugify,
 } from '../../utils'
 import { asyncDebugPerformance, DebugPerformanceContext } from '../../utils/logs'
 import { validateBwcBreakingChanges } from './bwc.validation'
-import { REST_API_TYPE } from '../../apitypes'
 
 export async function compareVersionsOperations(
   prev: VersionParams,
@@ -137,8 +135,8 @@ async function compareCurrentApiType(
   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 [prevReducedOperationIdToHashMap, prevReducedOperationIdToOriginal] = getOperationsHashMapByApiType(apiType, prevOperations, ctx)
-  const [currReducedOperationIdToHashMap, currReducedOperationIdToOriginal] = getOperationsHashMapByApiType(apiType, currOperations, ctx, true)
+  const [prevReducedOperationIdToHashMap, prevReducedOperationIdToOriginal] = getOperationsHashMapByApiType(apiBuilder, prevOperations, ctx)
+  const [currReducedOperationIdToHashMap, currReducedOperationIdToOriginal] = getOperationsHashMapByApiType(apiBuilder, currOperations, ctx, true)
 
   const reducedOperationIds = new Set([...Object.keys(prevReducedOperationIdToHashMap), ...Object.keys(currReducedOperationIdToHashMap)])
   const operationsMapping: OperationsMappingResult = { [HANDLE_TYPE_ADDED]: [], [HANDLE_TYPE_REMOVED]: [], [HANDLE_TYPE_CHANGED]: {} }
@@ -249,7 +247,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)
+    const pairOperationsMap = createPairOperationsMap(currGroupSlug, prevGroupSlug, currOperationsWithoutData, prevOperationsWithoutData, apiBuilder)
     Object.values(pairOperationsMap).forEach((pair) => {
       calculateApiAudienceTransitions(pair.current, pair.previous, apiAudienceTransitions)
     })
@@ -359,19 +357,26 @@ async function compareCurrentApiType(
   ]
 }
 
-const createPairOperationsMap = (currGroupSlug: string, prevGroupSlug: string, currentOperations: ResolvedOperation[], previousOperations: ResolvedOperation[]): Record<string, { previous?: ResolvedOperation; current: ResolvedOperation }> => {
+const createPairOperationsMap = (
+  currGroupSlug: string,
+  prevGroupSlug: string,
+  currentOperations: ResolvedOperation[],
+  previousOperations: ResolvedOperation[],
+  apiBuilder: ApiBuilder,
+): Record<string, {
+  previous?: ResolvedOperation
+  current: ResolvedOperation
+}> => {
 
   const operationsMap: Record<string, { previous?: ResolvedOperation; current: ResolvedOperation }> = {}
 
   for (const currentOperation of currentOperations) {
-    // todo
-    const normalizedOperationId = currentOperation.apiType === REST_API_TYPE ? slugify(`${currentOperation.metadata.path}-${currentOperation.metadata.method}`, [], IGNORE_PATH_PARAM_UNIFIED_PLACEHOLDER) : currentOperation.operationId
+    const normalizedOperationId = apiBuilder.createNormalizedOperationId?.(currentOperation) ?? currentOperation.operationId
     operationsMap[takeSubstringIf(!!currGroupSlug, normalizedOperationId, currGroupSlug.length)] = { current: currentOperation }
   }
 
   for (const previousOperation of previousOperations) {
-    // todo
-    const normalizedOperationId = previousOperation.apiType === REST_API_TYPE ? slugify(`${previousOperation.metadata.path}-${previousOperation.metadata.method}`, [], IGNORE_PATH_PARAM_UNIFIED_PLACEHOLDER) : previousOperation.operationId
+    const normalizedOperationId = apiBuilder.createNormalizedOperationId?.(previousOperation) ?? previousOperation.operationId
     const prevOperationId = takeSubstringIf(!!prevGroupSlug, normalizedOperationId, prevGroupSlug.length)
     const operationsMappingElement = operationsMap[prevOperationId]
     if (operationsMappingElement) {

src/components/compare/compare.utils.ts

@@ -15,10 +15,12 @@
  */
 
 import {
+  ApiBuilder,
   ChangeSummary,
   CompareContext,
   DIFF_TYPES,
   ImpactedOperationSummary,
+  NormalizedOperationId,
   OperationChangesMetadata,
   OperationId,
   OperationsApiType,
@@ -94,22 +96,19 @@ export function getOperationTypesFromTwoVersions(
 type OperationIdWithoutGroupPrefix = string
 export type OperationIdentityMap = Record<OperationIdWithoutGroupPrefix, OperationId>
 
-type NormalizedOperationId = `${NormalizedPath}-${OpenAPIV3.HttpMethods}`
-
 export function getOperationsHashMapByApiType(
-  currentApiType: OperationsApiType,
+  apiBuilder: ApiBuilder,
   operations: ResolvedOperation[],
   ctx: CompareContext,
   areOperationsFromCurrentVersion: boolean = false,
 ): [ResolvedVersionOperationsHashMap, OperationIdentityMap] {
   const { buildType, currentGroup, previousGroup } = ctx.config
-  const currentApiTypeOperations = operations.filter(({ apiType }) => apiType === currentApiType)
-
   const resolvedHashMap: ResolvedVersionOperationsHashMap = {}
   const normalizedToOriginalOperationIdMap: Record<NormalizedOperationId | OperationId, OperationId> = {}
 
-  for (const { operationId, apiType, metadata, dataHash } of currentApiTypeOperations) {
-    const normalizedOperationId = apiType === REST_API_TYPE ? slugify(`${metadata.path}-${metadata.method}`, [], IGNORE_PATH_PARAM_UNIFIED_PLACEHOLDER) : operationId
+  for (const operation of operations) {
+    const { operationId, dataHash } = operation
+    const normalizedOperationId = apiBuilder.createNormalizedOperationId?.(operation) ?? operationId
     resolvedHashMap[normalizedOperationId] = dataHash
     normalizedToOriginalOperationIdMap[normalizedOperationId] = operationId
   }

src/types/internal/apiBuilder.ts

@@ -75,6 +75,8 @@ export interface CompareOperationsPairContext {
   currentPackageId: PackageId
 }
 
+export type NormalizedOperationId = string
+
 export type FileParser = (fileId: string, data: Blob) => Promise<File | undefined>
 export type DocumentBuilder<T> = (parsedFile: TextFile, file: BuildConfigFile, ctx: BuilderContext<T>) => Promise<VersionDocument<T>>
 export type OperationsBuilder<T, M = any> = (document: VersionDocument<T>, ctx: BuilderContext<T>, debugCtx?: DebugPerformanceContext) => Promise<ApiOperation<M>[]>
@@ -85,6 +87,7 @@ export type OperationChangesValidator = (
   previousOperation?: RestOperationData, // TODO remove
   prePreviousOperation?: RestOperationData, // TODO remove
 ) => boolean
+export type OperationIdNormalizer = (operation: ResolvedOperation) => NormalizedOperationId
 export type BreakingChangeReclassifier = (changes: OperationChanges[], previousVersion: string, previousPackageId: string, ctx: CompareContext) => Promise<void>
 
 export interface ApiBuilder<T = any, O = any, M = any> {
@@ -96,6 +99,7 @@ export interface ApiBuilder<T = any, O = any, M = any> {
   buildOperations?: OperationsBuilder<T, M>
   compareOperationsData?: OperationDataCompare<O>
   validateOperationChanges?: OperationChangesValidator
+  createNormalizedOperationId?: OperationIdNormalizer
 }
 
 // internal