fix anyOf, oneOf and allOf types parsing

changelog.md

@@ -1,5 +1,10 @@
 # Open API Lambda Connector Changelog
 
+## Unreleased
+
+- Fix param parsing of `anyOf`, `allOf` and `oneOf` ([#83](https://github.com/hasura/ndc-open-api-lambda/pull/83))
+
+
 ## [[1.5.0](https://github.com/hasura/ndc-open-api-lambda/releases/tag/v1.5.0)] 2025-03-07
 
 - Update NDC NodeJS Lambda to `v1.11.0` [#80](https://github.com/hasura/ndc-open-api-lambda/pull/80)

src/app/generator/functions-ts-generator.test.ts

@@ -164,6 +164,24 @@ const tests: {
     goldenFile: "./golden-files/trello",
     baseUrl: "",
   },
+  {
+    name: "one-of-param-test",
+    openApiUri: "./open-api-docs/one-of-param-test.json",
+    goldenFile: "./golden-files/one-of-param-test",
+    baseUrl: "",
+  },
+  {
+    name: "any-of-param-test",
+    openApiUri: "./open-api-docs/one-of-param-test.json",
+    goldenFile: "./golden-files/one-of-param-test",
+    baseUrl: "",
+  },
+  {
+    name: "all-of-param-test",
+    openApiUri: "./open-api-docs/one-of-param-test.json",
+    goldenFile: "./golden-files/one-of-param-test",
+    baseUrl: "",
+  },
 ];
 
 describe("functions-ts-generator", async () => {

src/app/parser/open-api/param-types.ts

@@ -143,7 +143,12 @@ export function schemaIsTypeScalar(schema: any): schema is SchemaTypeScalar {
   return (
     schema.type &&
     Object.values(ScalarTypeEnum).includes(schema.type) &&
-    schema.properties === undefined
+    !schemaIsTypeObject(schema) &&  
+    !schemaIsTypeRef(schema)  &&
+    !schemaIsTypeArray(schema) &&
+    !schemaIsTypeAnyOf(schema) &&
+    !schemaIsTypeOneOf(schema) &&
+    !schemaIsTypeAllOf(schema)
   );
 }
 

tests/test-data/golden-files/all-of-param-test

@@ -0,0 +1,43 @@
+import * as hasuraSdk from "@hasura/ndc-lambda-sdk";
+import { Api } from "./api";
+
+const api = new Api({
+  baseUrl: `${process.env.NDC_OAS_BASE_URL}`,
+});
+
+/**
+ * Get total
+ * @request GET :/total
+ * @allowrelaxedtypes
+ * @readonly
+ */
+export async function getTotalTotalList(
+  query: {
+    content?: {
+      /** Depending of resurce, use different content params */
+      inner_content?: { fields?: { include?: string[] } } & {
+        expand?: { all?: hasuraSdk.JSONValue; false?: hasuraSdk.JSONValue };
+      } & {
+        structure?: {
+          /** Possible have empty object, or different parent or child combinations */
+          tree?: hasuraSdk.JSONValue;
+        };
+      };
+    };
+  },
+  headers?: hasuraSdk.JSONValue,
+): Promise<{
+  total?: number;
+}> {
+  const result = await api.total.totalList({
+    query: query,
+    params: {
+      headers: (headers?.value as Record<string, string>) ?? undefined,
+    },
+  });
+  if (result.data) {
+    return result.data;
+  } else {
+    throw result.error;
+  }
+}

tests/test-data/golden-files/any-of-param-test

@@ -0,0 +1,46 @@
+import * as hasuraSdk from "@hasura/ndc-lambda-sdk";
+import { Api } from "./api";
+
+const api = new Api({
+  baseUrl: `${process.env.NDC_OAS_BASE_URL}`,
+});
+
+/**
+ * Get total
+ * @request GET :/total
+ * @allowrelaxedtypes
+ * @readonly
+ */
+export async function getTotalTotalList(
+  query: {
+    content?: {
+      /** Depending of resurce, use different content params */
+      inner_content?:
+        | { fields?: { include?: string[] } }
+        | {
+            expand?: { all?: hasuraSdk.JSONValue; false?: hasuraSdk.JSONValue };
+          }
+        | {
+            structure?: {
+              /** Possible have empty object, or different parent or child combinations */
+              tree?: hasuraSdk.JSONValue;
+            };
+          };
+    };
+  },
+  headers?: hasuraSdk.JSONValue,
+): Promise<{
+  total?: number;
+}> {
+  const result = await api.total.totalList({
+    query: query,
+    params: {
+      headers: (headers?.value as Record<string, string>) ?? undefined,
+    },
+  });
+  if (result.data) {
+    return result.data;
+  } else {
+    throw result.error;
+  }
+}

tests/test-data/golden-files/one-of-param-test

@@ -0,0 +1,46 @@
+import * as hasuraSdk from "@hasura/ndc-lambda-sdk";
+import { Api } from "./api";
+
+const api = new Api({
+  baseUrl: `${process.env.NDC_OAS_BASE_URL}`,
+});
+
+/**
+ * Get total
+ * @request GET :/total
+ * @allowrelaxedtypes
+ * @readonly
+ */
+export async function getTotalTotalList(
+  query: {
+    content?: {
+      /** Depending of resurce, use different content params */
+      inner_content?:
+        | { fields?: { include?: string[] } }
+        | {
+            expand?: { all?: hasuraSdk.JSONValue; false?: hasuraSdk.JSONValue };
+          }
+        | {
+            structure?: {
+              /** Possible have empty object, or different parent or child combinations */
+              tree?: hasuraSdk.JSONValue;
+            };
+          };
+    };
+  },
+  headers?: hasuraSdk.JSONValue,
+): Promise<{
+  total?: number;
+}> {
+  const result = await api.total.totalList({
+    query: query,
+    params: {
+      headers: (headers?.value as Record<string, string>) ?? undefined,
+    },
+  });
+  if (result.data) {
+    return result.data;
+  } else {
+    throw result.error;
+  }
+}

tests/test-data/open-api-docs/all-of-param-test.json

@@ -0,0 +1,134 @@
+{
+  "openapi": "3.0.3",
+  "info": {},
+  "servers": [],
+  "security": [],
+  "paths": {
+    "/total": {
+      "get": {
+        "summary": "Get total",
+        "description": "Get total",
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/content"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Get Total",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "total": {
+                      "type": "integer"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            "$ref": "#/components/responses/BadRequestError"
+          },
+          "401": {
+            "$ref": "#/components/responses/AuthorizationError"
+          },
+          "403": {
+            "$ref": "#/components/responses/ForbiddenError"
+          },
+          "500": {
+            "$ref": "#/components/responses/ServerError"
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "parameters": {
+      "content": {
+        "name": "content",
+        "in": "query",
+        "required": false,
+        "example": "",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "inner_content": {
+              "type": "object",
+              "description": "Depending of resurce, use different content params",
+              "allOf": [
+                {
+                  "type": "object",
+                  "properties": {
+                    "fields": {
+                      "type": "object",
+                      "properties": {
+                        "include": {
+                          "type": "array",
+                          "items": {
+                            "type": "string"
+                          }
+                        }
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "expand": {
+                      "type": "object",
+                      "properties": {
+                        "all": {
+                          "type": "object"
+                        },
+                        "false": {
+                          "type": "object"
+                        }
+                      }
+                    }
+                  }
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "structure": {
+                      "type": "object",
+                      "properties": {
+                        "tree": {
+                          "type": "object",
+                          "description": "Possible have empty object, or different parent or child combinations"
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        }
+      }
+    },
+    "schemas": {},
+    "securitySchemes": {},
+    "responses": {
+      "BadRequestError": {
+        "description": "BadRequestError\n"
+      },
+      "AuthorizationError": {
+        "description": "AuthorizationError\n"
+      },
+      "ForbiddenError": {
+        "description": "ForbiddenError\n"
+      },
+      "NotFoundError": {
+        "description": "NotFoundError    \n"
+      },
+      "ServerError": {
+        "description": "ServerError\n"
+      }
+    }
+  }
+}