completed implementation for file uploads

Author: ioggstream

src/__tests__/__snapshots__/gen-api-models-oas3.test.ts.snap

@@ -501,7 +501,7 @@ exports[`gen-api-models should support file uploads 1`] = `
 
     // Request type definition
     export type TestFileUploadT = r.IPostApiRequestType<{readonly file: { uri: string, name: string, type: string }}, \\"Content-Type\\", never, r.IResponseType<200, undefined>>;
- 
+  
         // Decodes the success response with a custom success type
         export function testFileUploadDecoder<A, O>(type: t.Type<A, O>) { return r.ioResponseDecoder<200, (typeof type)[\\"_A\\"], (typeof type)[\\"_O\\"]>(200, type); }
 

src/__tests__/api_oas3.yaml

@@ -29,6 +29,7 @@ paths:
     post:
       operationId: testFileUpload
       requestBody:
+        required: true
         content:
           multipart/form-data:
             schema:

src/gen-api-models.ts

@@ -108,29 +108,74 @@ function getDecoderForResponse(status: string, type: string): string {
   }
 }
 
-// Get a schema from a request or response body
+/** Get the first schema from an OAS3 request or response body
+ */
 function getSchemaFromBody(
-item: any,			// OpenAPIV3.RequestBodyObject | 
-preferred_media_type: string | undefined
-): string | undefined {
+  item: any,
+): OpenAPIV3.BaseSchemaObject | string | undefined {
 
     try {
         const content = item.content;
-        if (preferred_media_type in content) {
-        	return item.content[preferred_media_type].schema.$ref;
+        const media_types = Object.keys(content);
+        
+        if (media_types.length == 0) {
+          console.warn(`Missing media-type in ${JSON.stringify(item)}`);
+          return undefined;
         }
-	// FIXME if there's more than one property then console.warn
-        const first_content = content[Object.keys(content)[0]]
-        if ($ref in first_content.schema) {
-            return first_content.schema.$ref;
+
+        if (media_types.length > 1) {
+            console.warn(`Multiple media-types in ${JSON.stringify(item)}`);
+            return undefined;
         }
-	return first_content.schema;
+
+        const media_type = content[media_types[0]];
+        return "$ref" in media_type.schema ? media_type.schema.$ref : media_type.schema;
+
     } catch {
-        console.warn(`f ${media_type } ${ JSON.stringify(item)}`);
+        console.warn(`Cannot get schema from body: ${JSON.stringify(item)}`);
         return undefined;
     }
 }
 
+/**
+ * Convert an OAS3 Object to typescript.
+ * This function supports only one level of schema properties:
+ *   for nested schemas define a schema object.
+ */
+function specObjectToTs(
+  item: any
+) : string | undefined {
+
+  if ((item.properties || item.type) == false) {
+    return undefined;
+  }
+
+  if (item.properties) {
+     item = item.properties;
+
+    // File upload implementation used in io-utils.
+    const file_upload_schema = {"file": {"type": "string", "format": "binary"}}
+    if (JSON.stringify(item) == JSON.stringify(file_upload_schema)) {
+      console.warn(`Found file upload pattern`);
+      return specTypeToTs("file");
+    }
+
+    for (let p in item) {
+      item[p] = item[p].type;
+    }
+    return JSON.stringify(item).replace(/"/g, " ");
+  }
+
+  if (item.type) {
+    // Support for generic OAS3 binary file upload
+    // see https://swagger.io/docs/specification/describing-request-body/file-upload/
+    if (item.type == "string" && item.format == "binary") {
+      return specTypeToTs("file");
+    }
+    return specTypeToTs(item.type);
+  }
+}
+
 export function renderOperation(
   method: string,
   operationId: string,
@@ -152,39 +197,46 @@ export function renderOperation(
   const importedTypes = new Set<string>();
 
   // Eventually process requestBody
-  if ((operation as any).requestBody !== undefined) {
-      const item = (operation as any).requestBody;
-      const application_json = "application/json"
-
-      console.warn(`requestBody ${ JSON.stringify(item) }`);
-      const typeRef = getSchemaFromBody(item, application_json); 
-
-      const parsedRef = typeRef ? typeFromRef(typeRef) : undefined;
-      console.warn(`requestBody.typeRef ${ JSON.stringify({'1': parsedRef, '2': typeRef}) }`);
-      if (parsedRef) {
-          const refType = parsedRef.e1; // "definition"
-    
-          // TODO implement if required...
-          const isParamRequired = false;
+  if (isV3OperationWithBody(operation) && operation.requestBody !== undefined) {
+    const item = operation.requestBody;
+    const typeRefOrSchema = getSchemaFromBody(item);
+    const isParamRequired = (item as OpenAPIV3.RequestBodyObject).required === true;
+    console.warn(`Required: ${isParamRequired}`);
+    if (typeRefOrSchema) {
+      const inlineRequestBody = specObjectToTs(typeRefOrSchema);
+
+      // inline parameter definition
+      if (inlineRequestBody){
+        const schema = (typeRefOrSchema as OpenAPIV3.BaseSchemaObject);
+        const parameterName = schema.properties
+          ? schema.properties.file
+            ? "file"
+            : "body"
+          : "body";
+        params[`${parameterName}${isParamRequired ? "" : "?"}`] = inlineRequestBody;
+      } else { // referenced parameter
+        const schema = (typeRefOrSchema as string);
+        const parsedRef = typeRefOrSchema ? typeFromRef(schema) : undefined;
+        console.debug(`requestBody.typeRef ${ JSON.stringify({'1': parsedRef, '2': typeRefOrSchema}) }`);
+
+        if (parsedRef) {
+          const refType = parsedRef.e1;
           const paramName = `${uncapitalize(parsedRef.e2)}${
             isParamRequired ? "" : "?"
           }`;
 
-          console.warn(`requestBody.paramName ${ JSON.stringify(paramName) }`);
-    
+          console.debug(`requestBody.paramName ${ JSON.stringify(paramName) }`);
           params[paramName] = parsedRef.e2;
           if (refType === "definition") {
             importedTypes.add(parsedRef.e2);
           }
-    
-
-      } else {
-        console.warn(`Cannot extract type from ref [${typeRef}]`);
+        }
       }
-
+    } else {
+      console.warn(`Cannot extract type from ref [${typeRefOrSchema}]`);
+    }
   }
 
-
   // Process ordinary parameters
   if (operation.parameters !== undefined) {
     const parameters = operation.parameters as Array<
@@ -453,6 +505,12 @@ export function isOpenAPIV3(
   return specs.hasOwnProperty("openapi");
 }
 
+export function isV3OperationWithBody(
+  item: any
+): item is OpenAPIV3.OperationObject {
+  return item.hasOwnProperty("requestBody");
+}
+
 export async function generateApi(
   env: nunjucks.Environment,
   specFilePath: string,