test

Author: lucy66hw

tools/proto-convert/src/VendorExtensionProcessor.ts

@@ -1,7 +1,8 @@
 import { OpenAPIV3 } from 'openapi-types';
 import { traverse } from './utils/OpenApiTraverser';
-import { resolveRef, deleteMatchingKeys } from './utils/helper';
+import { resolveRef, deleteMatchingKeys, remove_unused } from './utils/helper';
 import Logger from './utils/logger';
+import _ from 'lodash';
 
 /**
  * VendorExtensionProcessor class:
@@ -36,6 +37,8 @@ export class VendorExtensionProcessor {
     public process(): OpenAPIV3.Document {
         deleteMatchingKeys(this.root, (item: any) => this.hasProtobufExcluded(item));
 
+        remove_unused(this.root);
+
         traverse(this.root, {
             onParameter: (param: any, name: string) => {
                 this.applyNameOverrideToParameter(param);

tools/proto-convert/src/VersionProcessor.ts

@@ -1,7 +1,7 @@
 import _ from 'lodash';
 import * as semver from 'semver';
 import Logger from './utils/logger';
-import { deleteMatchingKeys } from './utils/helper';
+import { deleteMatchingKeys, remove_unused } from './utils/helper';
 import type { OpenAPIV3 } from 'openapi-types';
 
 /**
@@ -27,13 +27,10 @@ export class VersionProcessor {
     this._target_version = coerced?.toString() || currentVersion;
     this._logger.info(`Processing version constraints for OpenSearch ${this._target_version} ...`);
 
-    deleteMatchingKeys(this._spec, (item: any) => {
-      if (_.isObject(item) && this.#exclude_per_semver(item)) {
-        return true;
-      }
-      return false;
-    });
+    deleteMatchingKeys(this._spec, this.#exclude_per_semver.bind(this));
+    remove_unused(this._spec);
 
+    this._logger.info('Version processing complete');
     return this._spec;
   }
 

tools/proto-convert/src/utils/helper.ts

@@ -135,3 +135,68 @@ export function deleteMatchingKeys(obj: any, condition: (item: any) => boolean):
         }
     }
 }
+
+/**
+ * Find all $ref references in the spec, including nested references
+ */
+export function find_refs(
+    current: Record<string, any>,
+    root?: Record<string, any>,
+    call_stack: string[] = []
+): Set<string> {
+    const results = new Set<string>();
+
+    if (root === undefined) {
+        root = current;
+        current = current.paths;
+    }
+
+    if (current?.$ref != null) {
+        const ref = current.$ref as string;
+        results.add(ref);
+
+        const ref_node = resolveRef(ref, root as OpenAPIV3.Document);
+        if (ref_node !== undefined && !call_stack.includes(ref)) {
+            call_stack.push(ref);
+            find_refs(ref_node as Record<string, any>, root, call_stack).forEach((ref) => results.add(ref));
+        }
+    }
+
+    if (_.isObject(current)) {
+        _.forEach(current, (v) => {
+            find_refs(v as Record<string, any>, root, call_stack).forEach((ref) => results.add(ref));
+        });
+    }
+
+    return results;
+}
+
+/**
+ * Remove unused component definitions and broken $ref entries
+ */
+export function remove_unused(spec: OpenAPIV3.Document): void {
+    if (spec === undefined) return;
+
+    const references = find_refs(spec);
+
+    const componentTypes = ['parameters', 'requestBodies', 'responses', 'schemas'];
+    for (const componentType of componentTypes) {
+        const components = spec.components?.[componentType as keyof OpenAPIV3.ComponentsObject];
+        if (!components || !_.isObject(components)) continue;
+
+        for (const key of Object.keys(components)) {
+            if (!references.has(`#/components/${componentType}/${key}`)) {
+                delete components[key];
+            }
+        }
+    }
+
+    const remaining = _.flatMap(
+        ['schemas', 'parameters', 'responses', 'requestBodies'],
+        (key) => _.keys((spec?.components as any)?.[key]).map((ref) => `#/components/${key}/${ref}`)
+    );
+
+    deleteMatchingKeys(spec, (obj: any) =>
+        obj.$ref !== undefined && !_.includes(remaining, obj.$ref)
+    );
+}