chore: Adjust openapi generator for azure spec (#4953)

* add schema prefix option

* Changes from lint:fix

* parse properties + required

* Changes from lint:fix

* fix test

* fix

* Changes from lint:fix

* array has type obj with allOf only

* Changes from lint:fix

* fixes

* lint fix + log

* fix message

* empty string for prefix

* clean up

* refactor + tests

* Changes from lint:fix

* Update packages/openapi-generator/src/generator.ts

* regenerate with different name

* review remarks

* add comments

* additionalprop

* Changes from lint:fix

---------

Co-authored-by: cloud-sdk-js <cloud-sdk-js@github.com>
Co-authored-by: Marika Marszalkowski <868536+marikaner@users.noreply.github.com>

Author: 3 people

packages/openapi-generator/src/file-serializer/schema.ts

@@ -32,7 +32,9 @@ export function serializeSchema(schema: OpenApiSchema): string {
     const type = serializeSchema(schema.items);
     return schema.uniqueItems
       ? `Set<${type}>`
-      : 'properties' in schema.items
+      : ['properties', 'allOf', 'oneOf', 'anyOf'].some(
+            prop => prop in schema.items
+          )
         ? `(${type})[]`
         : `${type}[]`;
   }

packages/openapi-generator/src/parser/schema.spec.ts

@@ -416,6 +416,110 @@ describe('parseSchema', () => {
     );
   });
 
+  it('parses xOf schema ignoring type:object at same level', async () => {
+    const schema: OpenAPIV3.SchemaObject = {
+      type: 'object',
+      oneOf: [
+        { type: 'object' },
+        {
+          anyOf: [
+            { type: 'object' },
+            { allOf: [{ type: 'object' }, { type: 'string' }] }
+          ]
+        }
+      ]
+    };
+    expect(parseSchema(schema, await createTestRefs(), defaultOptions)).toEqual(
+      {
+        oneOf: [
+          emptyObjectSchema,
+          {
+            anyOf: [
+              emptyObjectSchema,
+              { allOf: [emptyObjectSchema, { type: 'string' }] }
+            ]
+          }
+        ]
+      }
+    );
+  });
+
+  it('normalizes xOf schemas with properties at same level', async () => {
+    const schema: OpenAPIV3.SchemaObject = {
+      type: 'object',
+      properties: { prop1: { type: 'string' } },
+      oneOf: [
+        { type: 'object' },
+        {
+          allOf: [{ type: 'object' }, { type: 'string' }]
+        }
+      ]
+    };
+    expect(parseSchema(schema, await createTestRefs(), defaultOptions)).toEqual(
+      {
+        oneOf: [
+          emptyObjectSchema,
+          { allOf: [emptyObjectSchema, { type: 'string' }] },
+          {
+            additionalProperties: { type: 'any' },
+            properties: [
+              {
+                name: 'prop1',
+                description: undefined,
+                required: false,
+                schema: {
+                  type: 'string'
+                },
+                schemaProperties: {}
+              }
+            ]
+          }
+        ]
+      }
+    );
+  });
+
+  it('parses xOf schemas with required', async () => {
+    const schema: OpenAPIV3.SchemaObject = {
+      oneOf: [
+        { type: 'object' },
+        {
+          allOf: [
+            { type: 'object', properties: { prop1: { type: 'string' } } },
+            { type: 'string' }
+          ],
+          required: ['prop1']
+        }
+      ]
+    };
+    expect(parseSchema(schema, await createTestRefs(), defaultOptions)).toEqual(
+      {
+        oneOf: [
+          emptyObjectSchema,
+          {
+            allOf: [
+              {
+                additionalProperties: { type: 'any' },
+                properties: [
+                  {
+                    name: 'prop1',
+                    description: undefined,
+                    required: true,
+                    schema: {
+                      type: 'string'
+                    },
+                    schemaProperties: {}
+                  }
+                ]
+              },
+              { type: 'string' }
+            ]
+          }
+        ]
+      }
+    );
+  });
+
   it('parses not schema', async () => {
     const schema: OpenAPIV3.SchemaObject = {
       not: { type: 'object' }

packages/openapi-generator/src/parser/schema.ts

@@ -42,14 +42,6 @@ export function parseSchema(
     return parseArraySchema(schema, refs, options);
   }
 
-  if (
-    schema.type === 'object' ||
-    schema.properties ||
-    'additionalProperties' in schema
-  ) {
-    return parseObjectSchema(schema, refs, options);
-  }
-
   if (schema.enum?.length) {
     return parseEnumSchema(schema, options);
   }
@@ -66,6 +58,16 @@ export function parseSchema(
     return parseXOfSchema(schema, refs, 'anyOf', options);
   }
 
+  // An object schema should be parsed after allOf, anyOf, oneOf.
+  // When object.properties are at the same level with anyOf, oneOf, allOf, they should be treated as part of allOf, etc.
+  if (
+    schema.type === 'object' ||
+    schema.properties ||
+    schema.additionalProperties
+  ) {
+    return parseObjectSchema(schema, refs, options);
+  }
+
   if (schema.not) {
     return {
       not: parseSchema(schema.not, refs, options)
@@ -223,11 +225,42 @@ function parseXOfSchema(
   xOf: 'oneOf' | 'allOf' | 'anyOf',
   options: ParserOptions
 ): any {
+  const normalizedSchema = normalizeSchema(schema, xOf);
+
   return {
-    [xOf]: (schema[xOf] || []).map(entry => parseSchema(entry, refs, options))
+    [xOf]: (normalizedSchema[xOf] || []).map(entry =>
+      parseSchema(
+        {
+          ...entry,
+          required: [
+            // Add required properties from the entry.
+            ...('required' in entry && entry.required ? entry.required : []),
+            // Add required properties from the top level schema (xOf).
+            ...(normalizedSchema.required || [])
+          ]
+        },
+        refs,
+        options
+      )
+    )
   };
 }
 
+function normalizeSchema(
+  schema: OpenAPIV3.NonArraySchemaObject,
+  xOf: 'oneOf' | 'allOf' | 'anyOf'
+): OpenAPIV3.NonArraySchemaObject {
+  if (schema.properties || schema.additionalProperties) {
+    logger.info(
+      `Detected schema with ${xOf} and properties in the same level. This was refactored to a schema with ${xOf} only, containing all the properties from the top level.`
+    );
+
+    const { [xOf]: xOfSchema = [], ...objectSchema } = schema;
+    return { [xOf]: [...xOfSchema, objectSchema] };
+  }
+  return schema;
+}
+
 /**
  * Parse schema properties e.g. 'maxLength', 'minimum', etc.
  * @param schema - Original schema representing a ref or schema object.

test-packages/test-services-openapi/swagger-yaml-service/schema/entity-x-of-inheritance.d.ts

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2024 SAP SE or an SAP affiliate company. All rights reserved.
+ *
+ * This is a generated file powered by the SAP Cloud SDK for JavaScript.
+ */
+import type { TestEntity } from './test-entity';
+/**
+ * Composition of extended properties (inheritance) and schema-specific properties together with required attribute.
+ */
+export type EntityXOfInheritance = TestEntity & {
+  booleanProperty: boolean;
+  integerProperty2?: number;
+} & Record<string, any>;

test-packages/test-services-openapi/swagger-yaml-service/schema/entity-x-of-inheritance.js

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2024 SAP SE or an SAP affiliate company. All rights reserved.
+ *
+ * This is a generated file powered by the SAP Cloud SDK for JavaScript.
+ */
+import type { TestEntity } from './test-entity';
+/**
+ * Composition of extended properties (inheritance) and schema-specific properties together with required attribute.
+ */
+export type EntityXOfInheritance = TestEntity & {
+  booleanProperty: boolean;
+  integerProperty2?: number;
+} & Record<string, any>;

test-packages/test-services-openapi/swagger-yaml-service/schema/entity-x-of-inheritance.js.map

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2024 SAP SE or an SAP affiliate company. All rights reserved.
+ *
+ * This is a generated file powered by the SAP Cloud SDK for JavaScript.
+ */
+import type { TestEntity } from './test-entity';
+/**
+ * Entity with xOf and schema properties at same level. This is normalized to only xOf with schema properties inside xOf. Also works if only additionalProperties true is used.
+ */
+export type EntityXOfNormalizedWithObject =
+  | TestEntity
+  | ({
+      booleanProperty: boolean;
+    } & Record<string, any>);