Add old behavior

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

Author: lucy66hw

DEVELOPER_GUIDE.md

@@ -234,8 +234,8 @@ npm config set registry https://registry.npmjs.org/
 3. **Generate Protobuf**
 
    ```bash
-  export OPENAPI_GENERATOR_VERSION=7.19.0
-  npx @openapitools/openapi-generator-cli generate \
+   export OPENAPI_GENERATOR_VERSION=7.19.0
+   npx @openapitools/openapi-generator-cli generate \
     -c tools/proto-convert/src/config/protobuf-generator-config.yaml
    ```
 

tools/proto-convert/src/SchemaModifier.ts

@@ -7,6 +7,7 @@ import logger from "./utils/logger";
 
 const DEFAULT_MAP_KEY = 'field' // default key for simplified additionalProperties
 const DEFAULT_MAP_VALUE = 'value' // default value for simplified additionalProperties
+const QUERY_CONTAINER_SCHEMA_NAME = 'QueryContainer' // schema name that requires special inline handling.
 
 export class SchemaModifier {
     root: OpenAPIV3.Document;
@@ -37,8 +38,8 @@ export class SchemaModifier {
         });
         const visit = new Set();
         traverse(this.root, {
-            onSchemaProperty: (schema) => {
-                this.simplifySingleMapSchema(schema, visit);
+            onSchemaProperty: (schema, propertyName, parentSchemaName) => {
+                this.simplifySingleMapSchema(schema, visit, parentSchemaName);
                 this.handleAdditionalPropertiesUndefined(schema)
 
             },
@@ -279,7 +280,6 @@ export class SchemaModifier {
 
     /**
      * Extracts type name from $ref or title
-     * Note: Schema names have already been sanitized by Sanitizer, so '___' prefixes are already removed
      **/
     private getTypeName(schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject): string | null {
         if ('$ref' in schema) {
@@ -293,58 +293,115 @@ export class SchemaModifier {
     }
 
     /**
-     * Transforms SchemaObject that single-key maps (`minProperties = 1` and `maxProperties = 1`) into a new wrapper schema.
-     *
+     * Transforms SchemaObject that single-key maps (`minProperties = 1` and `maxProperties = 1`) into a $ref to a new map schema.
      *
-     * Example:
-     *  Input:
+     *  Input (items of DecayFunction):
      * {
      *   type: "object",
+     *   propertyNames: { title: "field", type: "string" },
      *   additionalProperties: {
-     *     $ref: "#/components/schemas/SortOrder"
+     *     title: "placement",
+     *     $ref: "#/components/schemas/DecayPlacement"
      *   },
      *   minProperties: 1,
      *   maxProperties: 1,
      * }
      *
      * Output:
+     * - Replaces with: { $ref: "#/components/schemas/DecayPlacementSingleMap" }
+     * - Creates new schema DecayPlacementSingleMap:
      * {
      *   type: "object",
-     *   title: "SortOrderMap",
      *   properties: {
      *     field: { type: "string" },
-     *     sort_order: { $ref: "#/components/schemas/SortOrder" }
+     *     decay_placement: {
+     *       title: "placement",
+     *       $ref: "#/components/schemas/DecayPlacement"
+     *     }
      *   },
-     *   required: ["field", "sort_order"]
+     *   required: ["field", "decay_placement"]
      * }
      *
      **/
-    simplifySingleMapSchema(schema: OpenAPIV3.SchemaObject, visit: Set<any>): void {
+    simplifySingleMapSchema(schema: OpenAPIV3.SchemaObject, visit: Set<any>, parentSchemaName?: string): void {
         if (schema.type === 'object' && typeof schema.additionalProperties === 'object' &&
             !Array.isArray(schema.additionalProperties) && schema.minProperties === 1 && schema.maxProperties === 1){
 
+            // Check if this is a QueryContainer property
+            // If so, use the old inline behavior to avoid breaking QueryContainer structure
+            // TODO: Remove this special case in next major release and use SingleMap wrapper for all schemas
+            if (parentSchemaName === QUERY_CONTAINER_SCHEMA_NAME) {
+                logger.info(`Using inline modification for ${QUERY_CONTAINER_SCHEMA_NAME} property (legacy behavior)`+JSON.stringify(schema));
+                // Old behavior: inline modification
+                const reconstructAdditionalPropertySchema = this.reconstructAdditionalPropertySchema(schema.additionalProperties, visit);
+                Object.assign(schema, reconstructAdditionalPropertySchema);
+
+                delete schema.additionalProperties;
+                delete schema.minProperties;
+                delete schema.maxProperties;
+                delete schema.type;
+                if ('propertyNames' in schema) {
+                    delete schema.propertyNames;
+                }
+                return;
+            }
+
+            // New behavior: create intermediate SingleMap schema
             const valueSchema = schema.additionalProperties;
-            const typeName = this.getTypeName(valueSchema) || 'Value'; // Use 'Value' as fallback
-
-            // Create new wrapper schema
-            // Avoid collision with the reserved 'field' key property name
-            const rawPropertyName = toSnakeCase(typeName);
-            const valuePropertyName = rawPropertyName === 'field' ? `${rawPropertyName}_value` : rawPropertyName;
-            const wrapperTitle = schema.title || `${typeName}Map`;
-
-            schema.title = wrapperTitle;
-            schema.properties = {
-                field: { type: 'string' as const },
-                [valuePropertyName]: valueSchema
+            const typeName = this.getTypeName(valueSchema) || 'Value';
+
+            // Extract field property name and schema from propertyNames
+            let fieldPropertyName = 'field';
+            let fieldPropertySchema: any = { type: 'string' as const };
+
+            if ((schema as any).propertyNames) {
+                const propertyNames = (schema as any).propertyNames;
+
+                // If propertyNames has a title, use it as the property name
+                if (propertyNames.title && typeof propertyNames.title === 'string') {
+                    fieldPropertyName = propertyNames.title;
+
+                    fieldPropertySchema = { ...propertyNames };
+                    delete fieldPropertySchema.title;
+                } else {
+                    // Use propertyNames as-is for the field schema
+                    fieldPropertySchema = propertyNames;
+                }
+            }
+
+            // Create new map schema name
+            const mapSchemaName = `${typeName}SingleMap`;
+
+            // Create the new map schema
+            const newMapSchema: OpenAPIV3.SchemaObject = {
+                type: 'object',
+                properties: {
+                    [fieldPropertyName]: fieldPropertySchema,
+                    [toSnakeCase(typeName)]: valueSchema
+                },
+                required: [fieldPropertyName, toSnakeCase(typeName)]
             };
-            schema.required = ['field', valuePropertyName];
 
+            // Add to components.schemas if not already exists
+            if (!this.root.components) {
+                this.root.components = {};
+            }
+            if (!this.root.components.schemas) {
+                this.root.components.schemas = {};
+            }
+            if (!this.root.components.schemas[mapSchemaName]) {
+                this.root.components.schemas[mapSchemaName] = newMapSchema;
+            }
+
+            // Replace current schema with $ref to the new map schema
+            // Only delete the properties we don't need, keep vendor extensions (x-*)
+            delete schema.type;
             delete schema.additionalProperties;
             delete schema.minProperties;
             delete schema.maxProperties;
-            if ('propertyNames' in schema) {
-                delete schema.propertyNames;
-            }
+            delete (schema as any).propertyNames;
+
+            (schema as any).$ref = `#/components/schemas/${mapSchemaName}`;
         }
     }
 

tools/proto-convert/src/config/spec-filter.yaml

@@ -18,6 +18,7 @@ excluded_schemas:
   - CombinedFieldsQuery
   - DistanceFeatureQuery
   - GeoPolygonQuery
+  - GeoShapeQuery
   - HasChildQuery
   - HasParentQuery
   - MoreLikeThisQuery

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

@@ -5,7 +5,7 @@ export type SchemaVisitorSet = {
     onResponseSchema?: (schema: OpenAPIV3.SchemaObject, name: string) => void;
     onRequestSchema?: (schema: OpenAPIV3.SchemaObject, name: string) => void;
     onParameter?: (param: OpenAPIV3.ParameterObject, name: string) => void;
-    onSchemaProperty?: (schema: OpenAPIV3.SchemaObject, propertyName: string) => void;
+    onSchemaProperty?: (schema: OpenAPIV3.SchemaObject, propertyName: string, parentSchemaName?: string) => void;
 };
 
 /**
@@ -24,7 +24,7 @@ export function traverse(
             const schema = components.schemas[schemaName];
             visitors.onSchema?.(schema, schemaName);
             if (!('$ref' in schema)) {
-                traverseSchema(schema, visitors);
+                traverseSchema(schema, visitors, schemaName);
             }
         }
     }
@@ -79,7 +79,8 @@ export function traverse(
  */
 export function traverseSchema(
     schema: OpenAPIV3.SchemaObject,
-    visitors: SchemaVisitorSet
+    visitors: SchemaVisitorSet,
+    parentSchemaName?: string
 ): void {
     if (!schema) return;
 
@@ -88,21 +89,23 @@ export function traverseSchema(
         for (const propName in schema.properties) {
             const propSchema = schema.properties[propName];
             if (!('$ref' in propSchema)) {
-                visitors.onSchemaProperty?.(propSchema, propName);
-                traverseSchema(propSchema, visitors); // recurse into nested properties
+                visitors.onSchemaProperty?.(propSchema, propName, parentSchemaName);
+                traverseSchema(propSchema, visitors, parentSchemaName); // recurse into nested properties
             }
         }
     }
 
     // Visit items (for array types)
     if (schema.type === 'array' && schema.items && typeof schema.items === 'object' && !('$ref' in schema.items)) {
-        traverseSchema(schema.items as OpenAPIV3.SchemaObject, visitors);
+        const itemsSchema = schema.items as OpenAPIV3.SchemaObject;
+        visitors.onSchemaProperty?.(itemsSchema, 'items', parentSchemaName);
+        traverseSchema(itemsSchema, visitors, parentSchemaName);
     }
 
     // Visit additionalProperties
     if (schema.additionalProperties && typeof schema.additionalProperties === 'object' && !('$ref' in schema.additionalProperties)
     ) {
-        traverseSchema(schema.additionalProperties as OpenAPIV3.SchemaObject, visitors);
+        traverseSchema(schema.additionalProperties as OpenAPIV3.SchemaObject, visitors, parentSchemaName);
     }
 
     // Visit composed schemas
@@ -113,7 +116,7 @@ export function traverseSchema(
             for (const sub of subschemas) {
                 if (!('$ref' in sub)) {
                     visitors.onSchema?.(sub, `${key}`);
-                    traverseSchema(sub, visitors);
+                    traverseSchema(sub, visitors, parentSchemaName);
                 }
             }
         }