chore: merge branch 'develop' into feature/move-prefix-from-server-to-path

Author: b41ex

package.json

@@ -32,7 +32,7 @@
     "fast-equals": "4.0.3"
   },
   "devDependencies": {
-    "@netcracker/qubership-apihub-compatibility-suites": "2.3.0",
+    "@netcracker/qubership-apihub-compatibility-suites": "dev",
     "@netcracker/qubership-apihub-graphapi": "feature-performance-optimization",
     "@netcracker/qubership-apihub-npm-gitflow": "3.1.0",
     "@types/jest": "29.5.11",

src/api.ts

@@ -26,11 +26,24 @@ function areSpecTypesCompatible(beforeType: SpecType, afterType: SpecType): bool
   if (beforeType === afterType) {
     return true
   }
-  
+
   // Allow comparison between different OpenAPI versions
   return isOpenApiSpecVersion(beforeType) && isOpenApiSpecVersion(afterType)
 }
 
+function selectEngineSpecType(beforeType: SpecType, afterType: SpecType): SpecType {
+  // For OpenAPI version comparisons, use the higher version
+  if (isOpenApiSpecVersion(beforeType) && isOpenApiSpecVersion(afterType)) {
+    if (beforeType === SPEC_TYPE_OPEN_API_31 || afterType === SPEC_TYPE_OPEN_API_31) {
+      return SPEC_TYPE_OPEN_API_31
+    }
+    return SPEC_TYPE_OPEN_API_30
+  }
+
+  // For same spec types or other compatible types, use the before type
+  return beforeType
+}
+
 export const COMPARE_ENGINES_MAP: Record<SpecType, CompareEngine> = {
   [SPEC_TYPE_JSON_SCHEMA_04]: compareJsonSchema(SPEC_TYPE_JSON_SCHEMA_04),
   [SPEC_TYPE_JSON_SCHEMA_06]: compareJsonSchema(SPEC_TYPE_JSON_SCHEMA_06),
@@ -48,7 +61,7 @@ export function apiDiff(before: unknown, after: unknown, options: CompareOptions
   if (!areSpecTypesCompatible(beforeSpec.type, afterSpec.type)) {
     throw new Error(`Specification cannot be different. Got ${beforeSpec.type} and ${afterSpec.type}`)
   }
-  const engine = COMPARE_ENGINES_MAP[beforeSpec.type]
+  const engine = COMPARE_ENGINES_MAP[selectEngineSpecType(beforeSpec.type, afterSpec.type)]
   return engine(before, after, {
     mode: COMPARE_MODE_DEFAULT,
     normalizedResult: DEFAULT_NORMALIZED_RESULT,

src/core/compare.ts

@@ -34,7 +34,7 @@ import {
 } from '../types'
 import { getObjectValue, isArray, isDiffAdd, isDiffRemove, isDiffReplace, isNumber, isObject, typeOf } from '../utils'
 import { ANY_COMBINER_PATH, DiffAction, JSO_ROOT } from './constants'
-import { addDiffObjectToContainer, diffFactory, NEVER_KEY } from './diff'
+import { addDiffObjectToContainer, createDiffEntry, diffFactory, NEVER_KEY } from './diff'
 import { arrayMappingResolver, objectMappingResolver } from './mapping'
 
 const extractDeclarationPaths = (jso: Record<PropertyKey, unknown>, originMetaKey: symbol, property: PropertyKey): JsonPath[] => {
@@ -156,21 +156,24 @@ const cleanUpRecursive = (ctx: NodeContext): NodeContext => {
 }
 
 export const getOrCreateChildDiffAdd = (diffUniquenessCache: EvaluationCacheService, childCtx: CompareContext) => {
-  return diffUniquenessCache.cacheEvaluationResultByFootprint<[unknown, string, CompareScope, typeof DiffAction.add], DiffEntry<DiffAdd>>([childCtx.after.value, buildPathsIdentifier(childCtx.after.declarativePaths), childCtx.scope, DiffAction.add], () => {
+  const diff = diffUniquenessCache.cacheEvaluationResultByFootprint<[unknown, string, CompareScope, typeof DiffAction.add], DiffAdd>([childCtx.after.value, buildPathsIdentifier(childCtx.after.declarativePaths), childCtx.scope, DiffAction.add], () => {
     return diffFactory.added(childCtx)
-  }, {} as DiffEntry<DiffAdd>, (result, guard) => {
+  }, {} as DiffAdd, (result, guard) => {
     Object.assign(guard, result)
     return guard
   })
+
+  return createDiffEntry(childCtx, diff)
 }
 
 export const getOrCreateChildDiffRemove = (diffUniquenessCache: EvaluationCacheService, childCtx: CompareContext) => {
-  return diffUniquenessCache.cacheEvaluationResultByFootprint<[unknown, string, CompareScope, typeof DiffAction.remove], DiffEntry<DiffRemove>>([childCtx.before.value, buildPathsIdentifier(childCtx.before.declarativePaths), childCtx.scope, DiffAction.remove], () => {
+  const diff = diffUniquenessCache.cacheEvaluationResultByFootprint<[unknown, string, CompareScope, typeof DiffAction.remove], DiffRemove>([childCtx.before.value, buildPathsIdentifier(childCtx.before.declarativePaths), childCtx.scope, DiffAction.remove], () => {
     return diffFactory.removed(childCtx)
-  }, {} as DiffEntry<DiffRemove>, (result, guard) => {
+  }, {} as DiffRemove, (result, guard) => {
     Object.assign(guard, result)
     return guard
   })
+  return createDiffEntry(childCtx, diff)
 }
 
 const adaptValues = (beforeJso: JsonNode, beforeKey: PropertyKey, afterJso: JsonNode, afterKey: PropertyKey, adapter: AdapterResolver[] | undefined, options: InternalCompareOptions) => {
@@ -235,7 +238,7 @@ const useMergeFactory = (onDiff: DiffCallback, options: InternalCompareOptions):
 
     const beforeKey = unsafeKey ?? (isArray(beforeJso) ? +Object.keys(keyMap).pop()! : Object.keys(keyMap).pop())
     const afterKey = keyMap[beforeKey]
-    const mergeKey = isArray(mergedJso) && isNumber(beforeKey) ? beforeKey : afterKey//THIS IS VERY FRAGILE. Cause this logic duplicate this line mergedJsoValue[keyInMerge] = afterValue[keyInAfter]
+    const mergeKey = isArray(mergedJso) && isNumber(beforeKey) ? beforeKey : afterKey //gitleaks:allow //THIS IS VERY FRAGILE. Cause this logic duplicate this line mergedJsoValue[keyInMerge] = afterValue[keyInAfter]
 
     // skip if node was removed
     if (!(beforeKey in keyMap)) {
@@ -265,7 +268,7 @@ const useMergeFactory = (onDiff: DiffCallback, options: InternalCompareOptions):
 
     const reuseResult: ReusableMergeResult = mergedJsoCache.cacheEvaluationResultByFootprint<[typeof ctx.before.value, typeof ctx.after.value, typeof beforeDeclarativePathsId, typeof afterDeclarativePathsId, CompareScope], ReusableMergeResult>([ctx.before.value, ctx.after.value, beforeDeclarativePathsId, afterDeclarativePathsId, ctx.scope], ([beforeValue, afterValue]) => {
       if (!ignoreKeyDifference && beforeKey !== afterKey) {
-        const diffEntry = diffFactory.renamed(ctx)
+        const diffEntry = createDiffEntry(ctx, diffFactory.renamed(ctx))
         addDiff(diffEntry.diff)
         addDiffObjectToContainer(mergedJso, metaKey, [diffEntry])
       }
@@ -279,7 +282,7 @@ const useMergeFactory = (onDiff: DiffCallback, options: InternalCompareOptions):
 
       // types are different
       if (typeOf(beforeValue) !== typeOf(afterValue)) {
-        const diffEntry = diffFactory.replaced(ctx)
+        const diffEntry = createDiffEntry(ctx, diffFactory.replaced(ctx))
         addDiff(diffEntry.diff)
         return { diffsToPullUp: [diffEntry], mergedValue: afterValue } satisfies ReusableMergeResult
       }
@@ -336,7 +339,7 @@ const useMergeFactory = (onDiff: DiffCallback, options: InternalCompareOptions):
         diffsToPullUp: diffsToPullUp,
       }
       if (beforeValue !== afterValue) {
-        const diffEntry = diffFactory.replaced(ctx)
+        const diffEntry = createDiffEntry(ctx, diffFactory.replaced(ctx))
         diffsToPullUp.push(diffEntry)
         addDiff(diffEntry.diff)
       }

src/core/diff.ts

@@ -31,51 +31,46 @@ export const createDiff = <D extends Diff>(diff: Omit<D, 'type'>, ctx: CompareCo
   return mutableDiffCopy
 }
 
-export const diffFactory: DiffFactory = {
-  added: (ctx) => ({
-    propertyKey: ctx.mergeKey,
-    diff: createDiff({
-      afterValue: ctx.after?.value,
-      afterNormalizedValue: ctx.after?.value,
-      action: DiffAction.add,
-      afterDeclarationPaths: ctx.after.declarativePaths,
-      scope: ctx.scope,
-    }, ctx),
-  }),
-  removed: (ctx) => ({
-    propertyKey: ctx.mergeKey,
-    diff: createDiff({
-      beforeValue: ctx.before.value,
-      beforeNormalizedValue: ctx.before.value,
-      action: DiffAction.remove,
-      beforeDeclarationPaths: ctx.before.declarativePaths,
-      scope: ctx.scope,
-    }, ctx),
-  }),
-  replaced: (ctx) => ({
-    propertyKey: ctx.mergeKey,
-    diff: createDiff({
-      beforeValue: ctx.before.value,
-      beforeNormalizedValue: ctx.before.value,
-      afterValue: ctx.after.value,
-      afterNormalizedValue: ctx.after.value,
-      action: DiffAction.replace,
-      afterDeclarationPaths: ctx.after.declarativePaths,
-      beforeDeclarationPaths: ctx.before.declarativePaths,
-      scope: ctx.scope,
-    }, ctx),
-  }),
-  renamed: (ctx) => ({
+export function createDiffEntry(ctx: CompareContext, diff: Diff): DiffEntry<Diff> {
+  return ({
     propertyKey: ctx.mergeKey,
-    diff: createDiff({
-      beforeKey: ctx.before?.key,
-      afterKey: ctx.after?.key,
-      action: DiffAction.rename,
-      afterDeclarationPaths: ctx.after?.declarativePaths ?? [],
-      beforeDeclarationPaths: ctx.before?.declarativePaths ?? [],
-      scope: ctx.scope,
-    }, ctx),
-  }),
+    diff: diff,
+  })
+}
+
+export const diffFactory: DiffFactory = {
+  added: (ctx) => createDiff({
+    afterValue: ctx.after?.value,
+    afterNormalizedValue: ctx.after?.value,
+    action: DiffAction.add,
+    afterDeclarationPaths: ctx.after.declarativePaths,
+    scope: ctx.scope,
+  }, ctx),
+  removed: (ctx) => createDiff({
+    beforeValue: ctx.before.value,
+    beforeNormalizedValue: ctx.before.value,
+    action: DiffAction.remove,
+    beforeDeclarationPaths: ctx.before.declarativePaths,
+    scope: ctx.scope,
+  }, ctx),
+  replaced: (ctx) => createDiff({
+    beforeValue: ctx.before.value,
+    beforeNormalizedValue: ctx.before.value,
+    afterValue: ctx.after.value,
+    afterNormalizedValue: ctx.after.value,
+    action: DiffAction.replace,
+    afterDeclarationPaths: ctx.after.declarativePaths,
+    beforeDeclarationPaths: ctx.before.declarativePaths,
+    scope: ctx.scope,
+  }, ctx),
+  renamed: (ctx) => createDiff({
+    beforeKey: ctx.before?.key,
+    afterKey: ctx.after?.key,
+    action: DiffAction.rename,
+    afterDeclarationPaths: ctx.after?.declarativePaths ?? [],
+    beforeDeclarationPaths: ctx.before?.declarativePaths ?? [],
+    scope: ctx.scope,
+  }, ctx),
 }
 
 export const addDiffObjectToContainer = (

src/graphapi/graphapi.resolver.ts

@@ -1,4 +1,4 @@
-import { diffFactory } from '../core'
+import { createDiffEntry, diffFactory } from '../core'
 import { CompareResolver } from '../types/rules'
 import { isObject, isString } from '../utils'
 
@@ -9,17 +9,17 @@ export const complexTypeCompareResolver: CompareResolver = (ctx) => {
   const afterValue = after.value
 
   if (!isObject(beforeValue) || !isObject(afterValue) || !isString(beforeValue.kind) || !isString(afterValue.kind)) {
-    const diffEntry = diffFactory.replaced(ctx)
+    const diffEntry = createDiffEntry(ctx, diffFactory.replaced(ctx))
     // actually we don't make deep copy here and create "way to modify" original source. But fix not so trivial and expensive for performance
     return { diffs: [diffEntry.diff], ownerDiffEntry: diffEntry, merged: after.value }
   }
 
-  if (beforeValue.kind === afterValue.kind) { 
+  if (beforeValue.kind === afterValue.kind) {
     return undefined
   }
 
   //TODO add more better way to compare interface vs type 
 
-  const diffEntry = diffFactory.replaced(ctx)
+  const diffEntry = createDiffEntry(ctx, diffFactory.replaced(ctx))
   return { diffs: [diffEntry.diff], ownerDiffEntry: diffEntry, merged: after.value }
 }

src/jsonSchema/jsonSchema.resolver.ts

@@ -8,6 +8,7 @@ import {
   getOrCreateChildDiffAdd,
   getOrCreateChildDiffRemove,
   nestedCompare,
+  createDiffEntry,
 } from '../core'
 import type { CompareResolver, Diff, DiffEntry } from '../types'
 import { isArray, isObject, onlyExistedArrayIndexes } from '../utils'
@@ -21,7 +22,7 @@ export const combinersCompareResolver: CompareResolver = (ctx) => {
   }
 
   if (!isArray(before.value) || !isArray(after.value)) {
-    const diffEntry = diffFactory.replaced(ctx)
+    const diffEntry = createDiffEntry(ctx, diffFactory.replaced(ctx))
     // actually we don't make deep copy here and create "way to modify" original source
     return { diffs: [diffEntry.diff], ownerDiffEntry: diffEntry, merged: after.value }
   }