Preprocessing - Consolidate global parameters into GlobalParams schema

Signed-off-by: xil <fridalu66@gmail.com>

Author: lucy66hw

CHANGELOG.md

@@ -10,6 +10,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 - Preprocessing: Handle unnamed additionalProperties.([#272](https://github.com/opensearch-project/opensearch-protobufs/pull/272))
 - Support importing without proto file name knowledge in Python generated protobuf code ([#275](https://github.com/opensearch-project/opensearch-protobufs/pull/275))
 - Preprocessing - Add filter to not convert additionalProperties when only one key allowed ([#292](https://github.com/opensearch-project/opensearch-protobufs/pull/292))
+- Preprocessing - Consolidate global parameters into GlobalParams schema ([#293](https://github.com/opensearch-project/opensearch-protobufs/pull/293))
 
 ### Changed
 - Update preprocessing for x-protobuf-excluded ([#266](https://github.com/opensearch-project/opensearch-protobufs/pull/266))

tools/proto-convert/src/GlobalParamWrapper.ts

@@ -0,0 +1,161 @@
+import { OpenAPIV3 } from 'openapi-types';
+
+export class GlobalParameterConsolidator {
+    private root: OpenAPIV3.Document;
+    private globalParamRefs: Set<string> = new Set();
+    private globalParamDefinitions: Map<string, any> = new Map();
+
+    constructor(root: OpenAPIV3.Document) {
+        this.root = root;
+    }
+
+    /**
+     * Consolidates global query parameters into a single globalParams object.
+     *
+     */
+    consolidate(): OpenAPIV3.Document {
+        this.discoverGlobalParameters();
+
+        if (this.globalParamRefs.size === 0) {
+            console.log('No global parameters found');
+            return this.root;
+        }
+
+        this.createGlobalParamsSchema();
+
+        this.createGlobalParamsParameter();
+
+        this.replaceGlobalParamsInPaths();
+
+        return this.root;
+    }
+
+    /**
+     * Check all parameters marked with x-global: true
+     */
+    private discoverGlobalParameters(): void {
+        if (!this.root.components?.parameters) {
+            return;
+        }
+
+        // Check parameters for x-global: true
+        for (const [paramKey, paramDef] of Object.entries(this.root.components.parameters)) {
+            if (!paramDef) continue;
+
+            const param = paramDef as any;
+            if (param['x-global'] === true || param['x-global'] === 'true') {
+                const paramRef = `#/components/parameters/${paramKey}`;
+                this.globalParamRefs.add(paramRef);
+                this.globalParamDefinitions.set(paramKey, param);
+                console.log(`Found global parameter: ${paramKey}`);
+            }
+        }
+    }
+
+    private createGlobalParamsSchema(): void {
+        if (!this.root.components) {
+            this.root.components = {};
+        }
+        if (!this.root.components.schemas) {
+            this.root.components.schemas = {};
+        }
+
+        const properties: Record<string, any> = {};
+
+        for (const [paramKey, paramDef] of this.globalParamDefinitions) {
+            const paramName = paramDef.name || paramKey;
+            const schema = paramDef.schema || {};
+
+            const propertyObj: any = {
+                ...schema,
+                description: paramDef.description || schema.description,
+            };
+
+            for (const key in paramDef) {
+                if (key.startsWith('x-')) {
+                    propertyObj[key] = paramDef[key];
+                }
+            }
+
+            properties[paramName] = propertyObj;
+        }
+
+        const globalParamsSchema: OpenAPIV3.SchemaObject = {
+            type: 'object',
+            description: 'Global query parameters that apply to all operations',
+            properties,
+        };
+
+        (this.root.components.schemas as any).GlobalParams = globalParamsSchema;
+    }
+
+    private createGlobalParamsParameter(): void {
+        if (!this.root.components) {
+            this.root.components = {};
+        }
+        if (!this.root.components.parameters) {
+            this.root.components.parameters = {};
+        }
+
+        const globalParamsParam: any = {
+            name: 'globalParams',
+            in: 'query',
+            description: 'Global query parameters',
+            schema: {
+                $ref: '#/components/schemas/GlobalParams',
+            },
+            'x-global': true,
+        };
+
+        (this.root.components.parameters as any).globalParams = globalParamsParam;
+    }
+
+    private replaceGlobalParamsInPaths(): void {
+        if (!this.root.paths) {
+            return;
+        }
+
+        for (const pathKey in this.root.paths) {
+            const pathItem = this.root.paths[pathKey];
+            if (!pathItem) continue;
+
+            const methods = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head', 'trace'];
+            for (const method of methods) {
+                const operation = (pathItem as any)[method] as OpenAPIV3.OperationObject | undefined;
+                if (!operation) continue;
+
+                this.replaceGlobalParamsInOperation(operation);
+            }
+        }
+    }
+
+    private replaceGlobalParamsInOperation(operation: OpenAPIV3.OperationObject): void {
+        if (!operation.parameters) {
+            return;
+        }
+
+        const indicesToRemove: number[] = [];
+        let hasGlobalParams = false;
+
+        for (let i = 0; i < operation.parameters.length; i++) {
+            const param = operation.parameters[i];
+            const paramRef = (param as any).$ref;
+
+            if (paramRef && this.globalParamRefs.has(paramRef)) {
+                indicesToRemove.push(i);
+                hasGlobalParams = true;
+            }
+        }
+
+        for (let i = indicesToRemove.length - 1; i >= 0; i--) {
+            operation.parameters.splice(indicesToRemove[i], 1);
+        }
+
+        if (hasGlobalParams) {
+            const globalParamsRef: OpenAPIV3.ReferenceObject = {
+                $ref: '#/components/parameters/globalParams',
+            };
+            operation.parameters.push(globalParamsRef as any);
+        }
+    }
+}

tools/proto-convert/src/PreProcessing.ts

@@ -6,6 +6,7 @@ import Logger from './utils/logger';
 import * as path from 'path';
 import {SchemaModifier} from "./SchemaModifier";
 import {VendorExtensionProcessor} from "./VendorExtensionProcessor";
+import {GlobalParameterConsolidator} from "./GlobalParamWrapper";
 import type {OpenAPIV3} from "openapi-types";
 
 let config_filtered_path: string[] | undefined;
@@ -49,7 +50,8 @@ try {
   const original_spec = read_yaml(opts.input)
   const filtered_spec = new Filter().filter_spec(original_spec, opts.filtered_path);
   const sanitized_spec = new Sanitizer().sanitize(filtered_spec);
-  const vendor_processed_spec = new VendorExtensionProcessor(sanitized_spec, logger).process();
+  const consolidated_spec = new GlobalParameterConsolidator(sanitized_spec).consolidate();
+  const vendor_processed_spec = new VendorExtensionProcessor(consolidated_spec, logger).process();
   const schema_modified_spec = new SchemaModifier(vendor_processed_spec, logger).modify();
   write_yaml(opts.output, schema_modified_spec);