feat: aggregate operation diffs

Author: CountRedClaw

src/api.ts

@@ -15,7 +15,13 @@ import {
   SPEC_TYPE_OPEN_API_31,
   SpecType,
 } from '@netcracker/qubership-apihub-api-unifier'
-import { DEFAULT_NORMALIZED_RESULT, DEFAULT_OPTION_DEFAULTS_META_KEY, DEFAULT_OPTION_ORIGINS_META_KEY, DIFF_META_KEY } from './core'
+import {
+  DIFFS_AGGREGATED_META_KEY,
+  DEFAULT_NORMALIZED_RESULT,
+  DEFAULT_OPTION_DEFAULTS_META_KEY,
+  DEFAULT_OPTION_ORIGINS_META_KEY,
+  DIFF_META_KEY,
+} from './core'
 
 export const COMPARE_ENGINES_MAP: Record<SpecType, CompareEngine> = {
   [SPEC_TYPE_JSON_SCHEMA_04]: compareJsonSchema(SPEC_TYPE_JSON_SCHEMA_04),
@@ -41,6 +47,7 @@ export function apiDiff(before: unknown, after: unknown, options: CompareOptions
     metaKey: DIFF_META_KEY,
     defaultsFlag: DEFAULT_OPTION_DEFAULTS_META_KEY,
     originsFlag: DEFAULT_OPTION_ORIGINS_META_KEY,
+    diffsAggregatedFlag: DIFFS_AGGREGATED_META_KEY,
     compareScope: COMPARE_SCOPE_ROOT,
     mergedJsoCache: createEvaluationCacheService(),
     diffUniquenessCache: createEvaluationCacheService(),

src/core/compare.ts

@@ -1,4 +1,11 @@
-import { anyArrayKeys, getNodeRules, JsonPath, syncCrawl, SyncCrawlHook } from '@netcracker/qubership-apihub-json-crawl'
+import {
+  anyArrayKeys,
+  getNodeRules,
+  JsonPath,
+  syncClone,
+  syncCrawl,
+  SyncCrawlHook,
+} from '@netcracker/qubership-apihub-json-crawl'
 
 import {
   ChainItem,
@@ -16,6 +23,7 @@ import { deepEqual } from 'fast-equals'
 import {
   AdapterContext,
   AdapterResolver,
+  AGGREGATE_DIFFS_HERE_RULE,
   CompareContext,
   CompareResult,
   CompareRule,
@@ -473,7 +481,7 @@ export const compare = (before: unknown, after: unknown, options: InternalCompar
     return {
       diffs: rawDiffs,
       ownerDiffEntry: undefined,
-      merged,
+      merged: aggregateDiffs(merged, options),
     }
   }
   const diffFlags = Symbol('diffs')
@@ -491,8 +499,66 @@ export const compare = (before: unknown, after: unknown, options: InternalCompar
   return {
     diffs: denormalizedDiffs,
     ownerDiffEntry: undefined,
-    merged,
+    merged: merged,
+  }
+}
+
+export function aggregateDiffs(merged: unknown, options: InternalCompareOptions): unknown {
+  let activeDataCycleGuard: Set<unknown> = new Set()
+
+  const collectCurrentNodeDiffs = (value: Record<string | symbol, unknown>, operationDiffs: Set<Diff>) => {
+    if (options.metaKey in value) {
+      const diffs = value[options.metaKey] as Record<PropertyKey, unknown> | undefined
+      for (const key in diffs) {
+        // @ts-ignore
+        if (operationDiffs) {
+          // @ts-ignore
+          operationDiffs.add(diffs[key])
+        }
+      }
+    }
   }
+
+  syncClone(
+    merged,
+    [
+      ({ key, value, state, rules }) => {
+        if (!isObject(value)) {
+          return { value }
+        }
+        if (typeof key === 'symbol') {
+          // return { value }
+          return { done: true }
+        }
+        if (activeDataCycleGuard.has(value)) {
+          return { done: true }
+        }
+        activeDataCycleGuard.add(value)
+
+        // @ts-ignore
+        collectCurrentNodeDiffs(value, state.operationDiffs)
+
+        if (rules && AGGREGATE_DIFFS_HERE_RULE in rules) {
+          activeDataCycleGuard = new Set()
+          const operationDiffs = new Set<Diff>()
+          collectCurrentNodeDiffs(value, operationDiffs)
+          return {
+            value,
+            state: { ...state, operationDiffs },
+            exitHook: () => {
+              value[options.diffsAggregatedFlag] = operationDiffs
+            },
+          }
+        }
+        return { value }
+      },
+    ],
+    {
+      rules: options.rules
+    },
+  )
+
+  return merged
 }
 
 export const nestedCompare = (before: unknown, after: unknown, options: InternalCompareOptions): CompareResult => {

src/core/constants.ts

@@ -1,6 +1,7 @@
 import { ClassifyRule } from '../types'
 
 export const DIFF_META_KEY = Symbol('$diff')
+export const DIFFS_AGGREGATED_META_KEY = Symbol('$diffs-aggregated')
 export const DEFAULT_NORMALIZED_RESULT = false
 export const DEFAULT_OPTION_DEFAULTS_META_KEY = Symbol('$defaults')
 export const DEFAULT_OPTION_ORIGINS_META_KEY = Symbol('$origins')

src/graphapi/graphapi.rules.ts

@@ -18,7 +18,7 @@ import {
   deepEqualsUniqueItemsArrayMappingResolver
 } from '../core'
 import { resolveSchemaDescriptionTemplates } from '../jsonSchema'
-import type { ClassifyRule, CompareRules, DescriptionTemplates, MappingResolver } from '../types'
+import { AGGREGATE_DIFFS_HERE_RULE, ClassifyRule, CompareRules, DescriptionTemplates, MappingResolver } from '../types'
 import { graphApiSchemaAdapter as graphApiTypeAdapter, removeNotCorrectlySupportedInterfacesAdapter } from './graphapi.adapter'
 import { COMPARE_SCOPE_COMPONENTS, COMPARE_SCOPE_DIRECTIVE_USAGES, COMPARE_SCOPE_ARGS, COMPARE_SCOPE_OUTPUT } from './graphapi.const'
 import { complexTypeCompareResolver } from './graphapi.resolver'
@@ -335,18 +335,21 @@ export const graphApiRules = (): CompareRules => {
     '/queries': {
       '/*': {
         ...methodRules,
+        [AGGREGATE_DIFFS_HERE_RULE]: true,
         $: addNonBreaking
       },
     },
     '/mutations': {
       '/*': {
         ...methodRules,
+        [AGGREGATE_DIFFS_HERE_RULE]: true,
         $: addNonBreaking
       },
     },
     '/subscriptions': {
       '/*': {
         ...methodRules,
+        [AGGREGATE_DIFFS_HERE_RULE]: true,
         $: addNonBreaking
       }
     },

src/index.ts

@@ -1,7 +1,16 @@
 export { COMPARE_MODE_DEFAULT, COMPARE_MODE_OPERATION } from './types'
 
 export {
-  ClassifierType, DiffAction, DIFF_META_KEY, breaking, nonBreaking, unclassified, annotation, deprecated, risky,
+  ClassifierType,
+  DiffAction,
+  DIFF_META_KEY,
+  DIFFS_AGGREGATED_META_KEY,
+  breaking,
+  nonBreaking,
+  unclassified,
+  annotation,
+  deprecated,
+  risky,
 } from './core'
 
 export { apiDiff } from './api'

src/openapi/openapi3.rules.ts

@@ -30,6 +30,7 @@ import {
   deepEqualsUniqueItemsArrayMappingResolver,
 } from '../core'
 import {
+  AGGREGATE_DIFFS_HERE_RULE,
   COMPARE_MODE_OPERATION,
   CompareRules,
   DescriptionTemplates,
@@ -345,6 +346,7 @@ export const openApi3Rules = (options: OpenApi3RulesOptions): CompareRules => {
 
   const operationRule: CompareRules = {
     $: [nonBreaking, breaking, unclassified],
+    [AGGREGATE_DIFFS_HERE_RULE]: true,
     '/callbacks': {
       '/*': {
         //no support?

src/types/compare.ts

@@ -88,6 +88,7 @@ export interface CompareOptions extends Omit<NormalizeOptions, 'source'> {
   mode?: CompareMode
   normalizedResult?: boolean
   metaKey?: symbol         // metakey for merge changes
+  diffsAggregatedFlag?: symbol
   beforeSource?: unknown
   afterSource?: unknown
   onCreateDiffError?: (message: string, diff: Diff, ctx: CompareContext) => void
@@ -101,6 +102,7 @@ export interface StrictCompareOptions extends Omit<CompareOptions, 'defaultsFlag
   metaKey: symbol
   defaultsFlag: symbol,
   originsFlag: symbol,
+  diffsAggregatedFlag: symbol,
   compareScope: CompareScope
   mergedJsoCache: EvaluationCacheService
   diffUniquenessCache: EvaluationCacheService

src/types/rules.ts

@@ -82,6 +82,7 @@ export const DIFF_DESCRIPTION_PARAM_CALCULATOR_RULE = 'descriptionParamCalculato
 export const IGNORE_DIFFERENCE_IN_KEYS_RULE = 'ignoreKeyDifference'
 //not happy to do this, but introduce covariant support on core level too hard. If you can change it, feel free
 export const START_NEW_COMPARE_SCOPE_RULE = 'newCompareScope'
+export const AGGREGATE_DIFFS_HERE_RULE = 'aggregateDiffsHere'
 
 export type CompareRule = {
   [CLASSIFIER_RULE]?: ClassifyRule                           // classifier for current node
@@ -92,6 +93,7 @@ export type CompareRule = {
   [DIFF_DESCRIPTION_PARAM_CALCULATOR_RULE]?: DiffTemplateParamsCalculator               // rule for description calculation
   [IGNORE_DIFFERENCE_IN_KEYS_RULE]?: boolean                 // rule for ignore keys as values, it is relevant for arrays as sets
   [START_NEW_COMPARE_SCOPE_RULE]?: CompareScope // rule for star a new scope
+  [AGGREGATE_DIFFS_HERE_RULE]?: boolean
 }
 
 export type CompareRules = CrawlRules<CompareRule>