convert aggregation

Author: lucy66hw

tools/proto-convert/src/SchemaModifier.ts

@@ -34,6 +34,7 @@ export class SchemaModifier {
                 this.collapseOrMergeOneOfArray(schema)
                 this.collapseOneOfObjectPropContainsTitleSchema(schema)
                 this.removeArrayOfMapWrapper(schema)
+                this.convertOneOfToMinMaxProperties(schema)
             },
         });
         const visit = new Set();
@@ -477,6 +478,110 @@ export class SchemaModifier {
         }
     }
 
+    /**
+     * Converts oneOf pattern with single-property objects into minProperties/maxProperties pattern.
+     * This allows the template to recognize it as a oneof constraint.
+     *
+     * Example:
+     *   Input:
+     *   {
+     *     allOf: [
+     *       { properties: { meta: {...} } },
+     *       { oneOf: [
+     *           { properties: { field1: {...} }, required: [field1] },
+     *           { properties: { field2: {...} }, required: [field2] }
+     *         ]
+     *       }
+     *     ]
+     *   }
+     *
+     *   Output:
+     *   {
+     *     allOf: [
+     *       { properties: { meta: {...} } },
+     *       {
+     *         properties: {
+     *           field1: {...},
+     *           field2: {...}
+     *         },
+     *         minProperties: 1,
+     *         maxProperties: 1
+     *       }
+     *     ]
+     *   }
+     **/
+    convertOneOfToMinMaxProperties(schema: OpenAPIV3.SchemaObject): void {
+        // Check allOf/anyOf/oneOf for oneOf patterns
+        const composedKeys = ['allOf', 'anyOf', 'oneOf'] as const;
+
+        for (const key of composedKeys) {
+            const items = schema[key];
+            if (Array.isArray(items)) {
+                for (let i = 0; i < items.length; i++) {
+                    const item = items[i];
+                    if (item && typeof item === 'object' && !('$ref' in item)) {
+                        const itemSchema = item as any;
+
+                        // Check if this item has a oneOf with single-property patterns
+                        if (Array.isArray(itemSchema.oneOf) && itemSchema.oneOf.length > 0) {
+                            if (this.isOneOfWithSingleProperties(itemSchema.oneOf)) {
+                                // Convert oneOf to minProperties/maxProperties pattern
+                                this.flattenOneOfToProperties(itemSchema);
+                                this.logger.info(`Converted oneOf pattern to minProperties/maxProperties`);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Checks if oneOf items are all single-property objects
+     **/
+    private isOneOfWithSingleProperties(oneOfItems: any[]): boolean {
+        return oneOfItems.every(item => {
+            if (!item || typeof item !== 'object' || '$ref' in item) {
+                return false;
+            }
+            // Check if item has exactly one property and a required field
+            const hasProperties = item.properties && Object.keys(item.properties).length === 1;
+            const hasRequired = Array.isArray(item.required) && item.required.length === 1;
+            return hasProperties && hasRequired;
+        });
+    }
+
+    /**
+     * Flattens oneOf structure into merged properties with minProperties/maxProperties
+     **/
+    private flattenOneOfToProperties(schema: any): void {
+        if (!Array.isArray(schema.oneOf)) {
+            return;
+        }
+
+        const mergedProperties: any = {};
+
+        // Merge all properties from each oneOf item
+        for (const item of schema.oneOf) {
+            if (item && item.properties) {
+                Object.assign(mergedProperties, item.properties);
+            }
+        }
+
+        // Replace oneOf with merged properties and add constraints
+        schema.properties = mergedProperties;
+        schema.minProperties = 1;
+        schema.maxProperties = 1;
+
+        // Remove unevaluatedProperties if present
+        if ('unevaluatedProperties' in schema) {
+            delete schema.unevaluatedProperties;
+        }
+
+        delete schema.oneOf;
+        delete schema.required;
+    }
+
     /**
      * Marks schemas and properties with oneOf extensions.
      * Adds x-oneof-property to properties when schema has maxProperties=1.