@f3liz/rescript-autogen-openapi 0.1.0

package/src/generators/IRToTypeGenerator.res

@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// IRToTypeGenerator.res - Generate ReScript types from Schema IR
+open Types
+
+let addWarning = GenerationContext.addWarning
+
+let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType: SchemaIR.irType): string => {
+  // We keep a high depth limit just to prevent infinite recursion on circular schemas that escaped IRBuilder
+  if depth > 100 {
+    addWarning(ctx, DepthLimitReached({depth, path: ctx.path}))
+    "JSON.t"
+  } else {
+    let recurse = nextIrType => generateTypeWithContext(~ctx, ~depth=depth + 1, nextIrType)
+
+    switch irType {
+    | String(_) => "string"
+    | Number(_) => "float"
+    | Integer(_) => "int"
+    | Boolean => "bool"
+    | Null => "unit"
+    | Array({items}) => `array<${recurse(items)}>`
+    | Object({properties, additionalProperties}) =>
+      if Array.length(properties) == 0 {
+        switch additionalProperties {
+        | Some(valueType) => `dict<${recurse(valueType)}>`
+        | None => "JSON.t"
+        }
+      } else {
+        let fields =
+          properties
+          ->Array.map(((name, fieldType, isRequired)) => {
+            let typeCode = recurse(fieldType)
+            let finalType = isRequired ? typeCode : `option<${typeCode}>`
+            let camelName = name->CodegenUtils.toCamelCase
+            let escapedName = camelName->CodegenUtils.escapeKeyword
+            let aliasAnnotation = escapedName != name ? `@as("${name}") ` : ""
+            `  ${aliasAnnotation}${escapedName}: ${finalType},`
+          })
+          ->Array.join("\n")
+        `{\n${fields}\n}`
+      }
+    | Literal(value) =>
+      switch value {
+      | StringLiteral(_) => "string"
+      | NumberLiteral(_) => "float"
+      | BooleanLiteral(_) => "bool"
+      | NullLiteral => "unit"
+      }
+    | Union(types) =>
+      // Attempt to simplify common union patterns
+      let (hasArray, hasNonArray, arrayItemType, nonArrayType) = types->Array.reduce(
+        (false, false, None, None),
+        ((hArr, hNonArr, arrItem, nonArr), t) =>
+          switch t {
+          | Array({items}) => (true, hNonArr, Some(items), nonArr)
+          | _ => (hArr, true, arrItem, Some(t))
+          },
+      )
+
+      if (
+        hasArray &&
+        hasNonArray &&
+        SchemaIR.equals(Option.getOr(arrayItemType, Unknown), Option.getOr(nonArrayType, Unknown))
+      ) {
+        `array<${recurse(Option.getOr(arrayItemType, Unknown))}>`
+      } else if (
+        types->Array.every(t =>
+          switch t {
+          | Literal(StringLiteral(_)) => true
+          | _ => false
+          }
+        ) &&
+        Array.length(types) > 0 &&
+        Array.length(types) <= 50
+      ) {
+        let variants =
+          types
+          ->Array.map(t =>
+            switch t {
+            | Literal(StringLiteral(s)) => `#${CodegenUtils.toPascalCase(s)}`
+            | _ => "#Unknown"
+            }
+          )
+          ->Array.join(" | ")
+        `[${variants}]`
+      } else {
+        addWarning(
+          ctx,
+          ComplexUnionSimplified({
+            location: ctx.path,
+            types: types->Array.map(SchemaIR.toString)->Array.join(" | "),
+          }),
+        )
+        "JSON.t"
+      }
+    | Intersection(types) =>
+      // Basic support for intersections by picking the last reference or falling back
+      if types->Array.every(t =>
+        switch t {
+        | Reference(_) => true
+        | _ => false
+        }
+      ) && Array.length(types) > 0 {
+        recurse(types->Array.get(Array.length(types) - 1)->Option.getOr(Unknown))
+      } else {
+        addWarning(
+          ctx,
+          IntersectionNotFullySupported({location: ctx.path, note: "Complex intersection"}),
+        )
+        "JSON.t"
+      }
+    | Option(inner) => `option<${recurse(inner)}>`
+    | Reference(ref) =>
+      let typePath = switch ctx.availableSchemas {
+      | Some(available) =>
+        let name =
+          ref
+          ->String.split("/")
+          ->Array.get(ref->String.split("/")->Array.length - 1)
+          ->Option.getOr("")
+        available->Array.includes(name)
+          ? `${CodegenUtils.toPascalCase(name)}.t`
+          : `ComponentSchemas.${CodegenUtils.toPascalCase(name)}.t`
+      | None =>
+        ReferenceResolver.refToTypePath(
+          ~insideComponentSchemas=ctx.insideComponentSchemas,
+          ~modulePrefix=ctx.modulePrefix,
+          ref,
+        )->Option.getOr("JSON.t")
+      }
+      if typePath == "JSON.t" {
+        addWarning(
+          ctx,
+          FallbackToJson({
+            reason: `Unresolved ref: ${ref}`,
+            context: {path: ctx.path, operation: "gen ref", schema: None},
+          }),
+        )
+      }
+      typePath
+    | Unknown => "JSON.t"
+    }
+  }
+}
+
+let generateType = (
+  ~depth=0,
+  ~path="",
+  ~insideComponentSchemas=false,
+  ~availableSchemas=?,
+  ~modulePrefix="",
+  irType,
+) => {
+  let ctx = GenerationContext.make(~path, ~insideComponentSchemas, ~availableSchemas?, ~modulePrefix, ())
+  (generateTypeWithContext(~ctx, ~depth, irType), ctx.warnings)
+}
+
+let generateNamedType = (
+  ~namedSchema: SchemaIR.namedSchema,
+  ~insideComponentSchemas=false,
+  ~availableSchemas=?,
+  ~modulePrefix="",
+) => {
+  let ctx = GenerationContext.make(
+    ~path=`type.${namedSchema.name}`,
+    ~insideComponentSchemas,
+    ~availableSchemas?,
+    ~modulePrefix,
+    (),
+  )
+  let doc = switch namedSchema.description {
+  | Some(d) => CodegenUtils.generateDocString(~description=d, ())
+  | None => ""
+  }
+  (
+    `${doc}type ${namedSchema.name} = ${generateTypeWithContext(~ctx, ~depth=0, namedSchema.type_)}`,
+    ctx.warnings,
+  )
+}
+
+let generateAllTypes = (~context: SchemaIR.schemaContext) => {
+  let warnings = []
+  let types =
+    Dict.valuesToArray(context.schemas)
+    ->Array.toSorted((a, b) => String.compare(a.name, b.name))
+    ->Array.map(s => {
+      let (code, w) = generateNamedType(~namedSchema=s)
+      warnings->Array.pushMany(w)
+      code
+    })
+  (types, warnings)
+}
+
+let generateTypeAndSchema = (~namedSchema) => {
+  let (tCode, tW) = generateNamedType(~namedSchema)
+  let (sCode, sW) = IRToSuryGenerator.generateNamedSchema(~namedSchema)
+  ((tCode, sCode), Array.concat(tW, sW))
+}

package/src/generators/IRToTypeScriptGenerator.res

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// IRToTypeScriptGenerator.res - Convert SchemaIR to TypeScript types
+
+let rec generateType = (~irType: SchemaIR.irType, ~isOptional=false) =>
+  switch irType {
+  | String(_) => "string"
+  | Number(_)
+  | Integer(_) => "number"
+  | Boolean => "boolean"
+  | Null => "null"
+  | Unknown => "unknown"
+  | Array({items}) => `${generateType(~irType=items)}[]`
+  | Object({properties, additionalProperties}) =>
+    generateObjectType(~properties, ~additionalProperties)
+  | Literal(literal) =>
+    switch literal {
+    | StringLiteral(s) => `"${s}"`
+    | NumberLiteral(n) => Float.toString(n)
+    | BooleanLiteral(b) => b ? "true" : "false"
+    | NullLiteral => "null"
+    }
+  | Union(types) => types->Array.map(t => generateType(~irType=t))->Array.join(" | ")
+  | Intersection(types) => types->Array.map(t => generateType(~irType=t))->Array.join(" & ")
+  | Reference(ref) =>
+    switch String.split(ref, "/") {
+    | [_, "components", "schemas", name] => `ComponentSchemas.${name}`
+    | _ => ref
+    }
+  | Option(inner) =>
+    isOptional ? generateType(~irType=inner, ~isOptional=true) : `${generateType(~irType=inner)} | undefined`
+  }
+
+and generateObjectType = (~properties, ~additionalProperties) => {
+  let propertyLines = properties->Array.map(((name, fieldType, isRequired)) => {
+    let (actualType, isFieldOptional) = switch fieldType {
+    | SchemaIR.Option(inner) => (inner, true)
+    | _ => (fieldType, !isRequired)
+    }
+    `  ${name}${isFieldOptional ? "?" : ""}: ${generateType(~irType=actualType, ~isOptional=true)};`
+  })
+
+  let additionalPropertiesLines =
+    additionalProperties->Option.mapOr([], valueType => [
+      `  [key: string]: ${generateType(~irType=valueType)};`,
+    ])
+
+  let allLines = Array.concat(propertyLines, additionalPropertiesLines)
+
+  if allLines->Array.length == 0 {
+    "Record<string, never>"
+  } else {
+    `{\n${allLines->Array.join("\n")}\n}`
+  }
+}
+
+let generateNamedType = (~namedSchema: SchemaIR.namedSchema) => {
+  let docComment = namedSchema.description->Option.mapOr("", description => `/** ${description} */\n`)
+  let typeCode = generateType(~irType=namedSchema.type_)
+
+  let declaration = switch namedSchema.type_ {
+  | Object(_) => `export interface ${namedSchema.name} ${typeCode}`
+  | _ => `export type ${namedSchema.name} = ${typeCode};`
+  }
+
+  docComment ++ declaration
+}
+
+let generateParameterType = (~name, ~schema: Types.jsonSchema) => {
+  let (ir, _) = SchemaIRParser.parseJsonSchema(schema)
+  (CodegenUtils.toCamelCase(name), generateType(~irType=ir))
+}

package/src/generators/ModuleGenerator.res

@@ -0,0 +1,362 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// ModuleGenerator.res - Generate API modules organized by tags or in a flat structure
+open Types
+
+let generateSchemaCodeForDict = (schemaDict: dict<jsonSchema>) =>
+  Dict.toArray(schemaDict)
+  ->Array.toSorted(((nameA, _), (nameB, _)) => String.compare(nameA, nameB))
+  ->Array.flatMap(((name, schema)) => {
+    let (ir, _) = SchemaIRParser.parseJsonSchema(schema)
+    let (typeCode, _) = IRToTypeGenerator.generateNamedType(
+      ~namedSchema={name: name, description: schema.description, type_: ir},
+    )
+    let (schemaCode, _) = IRToSuryGenerator.generateNamedSchema(
+      ~namedSchema={name: `${name}Schema`, description: schema.description, type_: ir},
+    )
+    [typeCode->CodegenUtils.indent(2), schemaCode->CodegenUtils.indent(2), ""]
+  })
+
+let generateTagModulesCode = (endpoints: array<endpoint>, ~overrideDir=?, ~indent=2) => {
+  let groupedByTag = OpenAPIParser.groupByTag(endpoints)
+  let indentStr = " "->String.repeat(indent)
+
+  Dict.keysToArray(groupedByTag)
+  ->Array.toSorted(String.compare)
+  ->Array.filterMap(tag =>
+    groupedByTag
+    ->Dict.get(tag)
+    ->Option.map(tagEndpoints => {
+      let moduleName = CodegenUtils.toPascalCase(tag)
+      let endpointLines = tagEndpoints->Array.flatMap(endpoint => [
+        EndpointGenerator.generateEndpointCode(
+          endpoint,
+          ~overrideDir?,
+          ~moduleName,
+        )->CodegenUtils.indent(indent + 2),
+        "",
+      ])
+      Array.concat(
+        [`${indentStr}module ${moduleName} = {`],
+        Array.concat(endpointLines, [`${indentStr}}`, ""]),
+      )
+    })
+  )
+  ->Array.flatMap(lines => lines)
+}
+
+let generateTagModuleFile = (
+  ~tag,
+  ~endpoints,
+  ~includeSchemas as _: bool=true,
+  ~wrapInModule=false,
+  ~overrideDir=?,
+) => {
+  let moduleName = CodegenUtils.toPascalCase(tag)
+  let header = CodegenUtils.generateFileHeader(~description=`API endpoints for ${tag}`)
+  let body =
+    endpoints
+    ->Array.map(endpoint =>
+      EndpointGenerator.generateEndpointCode(endpoint, ~overrideDir?, ~moduleName)
+    )
+    ->Array.join("\n\n")
+
+  if wrapInModule {
+    `
+      |${header->String.trimEnd}
+      |
+      |module ${moduleName} = {
+      |${body->CodegenUtils.indent(2)}
+      |}
+      |`->CodegenUtils.trimMargin
+  } else {
+    `
+      |${header->String.trimEnd}
+      |
+      |${body}
+      |`->CodegenUtils.trimMargin
+  }
+}
+
+let generateAllTagModules = (
+  ~endpoints,
+  ~includeSchemas=true,
+  ~wrapInModule=false,
+  ~overrideDir=?,
+) => {
+  let groupedByTag = OpenAPIParser.groupByTag(endpoints)
+  Dict.toArray(groupedByTag)
+  ->Array.toSorted(((tagA, _), (tagB, _)) => String.compare(tagA, tagB))
+  ->Array.map(((tag, tagEndpoints)) => (
+    tag,
+    generateTagModuleFile(~tag, ~endpoints=tagEndpoints, ~includeSchemas, ~wrapInModule, ~overrideDir?),
+  ))
+}
+
+let generateIndexModule = (~tags, ~moduleName="API") => {
+  let header = CodegenUtils.generateFileHeader(~description="Main API module index")
+  let modules =
+    tags
+    ->Array.toSorted(String.compare)
+    ->Array.map(tag => {
+      let m = CodegenUtils.toPascalCase(tag)
+      `  module ${m} = ${m}`
+    })
+    ->Array.join("\n")
+
+  `
+    |${header->String.trimEnd}
+    |
+    |module ${moduleName} = {
+    |${modules}
+    |}
+    |`->CodegenUtils.trimMargin
+}
+
+let generateFlatModuleCode = (~moduleName, ~endpoints, ~overrideDir=?) => {
+  let header = CodegenUtils.generateFileHeader(~description=`All API endpoints in ${moduleName}`)
+  let body =
+    endpoints
+    ->Array.map(endpoint =>
+      EndpointGenerator.generateEndpointCode(
+        endpoint,
+        ~overrideDir?,
+        ~moduleName,
+      )->CodegenUtils.indent(2)
+    )
+    ->Array.join("\n\n")
+
+  `
+    |${header->String.trimEnd}
+    |
+    |module ${moduleName} = {
+    |${body}
+    |}
+    |`->CodegenUtils.trimMargin
+}
+
+let internalGenerateIntegratedModule = (
+  ~name,
+  ~description,
+  ~endpoints,
+  ~schemas,
+  ~overrideDir=?,
+  ~isExtension=false,
+  ~includeHeader=true,
+) => {
+  let lines = []
+  
+  if includeHeader {
+    lines->Array.pushMany([CodegenUtils.generateFileHeader(~description), ""])
+  }
+
+  lines->Array.push(`module ${name} = {`)
+
+  schemas->Option.forEach(schemaDict =>
+    if Dict.keysToArray(schemaDict)->Array.length > 0 {
+      lines->Array.pushMany([
+        `  // ${isExtension ? "Extension" : "Component"} Schemas`,
+        "",
+        ...generateSchemaCodeForDict(schemaDict),
+      ])
+    }
+  )
+
+  if Array.length(endpoints) > 0 {
+    if isExtension {
+      lines->Array.pushMany(["  // Extension Endpoints", ""])
+    }
+    lines->Array.pushMany(generateTagModulesCode(endpoints, ~overrideDir?))
+  }
+
+  lines->Array.push("}")
+  Array.join(lines, "\n")
+}
+
+let generateSharedModule = (~endpoints, ~schemas, ~overrideDir=?, ~includeHeader=true) =>
+  internalGenerateIntegratedModule(
+    ~name="Shared",
+    ~description="Shared API code",
+    ~endpoints,
+    ~schemas,
+    ~overrideDir?,
+    ~includeHeader,
+  )
+
+let generateExtensionModule = (~forkName, ~endpoints, ~schemas, ~overrideDir=?, ~includeHeader=true) =>
+  internalGenerateIntegratedModule(
+    ~name=`${CodegenUtils.toPascalCase(forkName)}Extensions`,
+    ~description=`${forkName} extensions`,
+    ~endpoints,
+    ~schemas,
+    ~overrideDir?,
+    ~isExtension=true,
+    ~includeHeader,
+  )
+
+let generateCombinedModule = (
+  ~forkName,
+  ~sharedEndpoints,
+  ~extensionEndpoints,
+  ~sharedSchemas,
+  ~extensionSchemas,
+  ~overrideDir=?,
+) => {
+  let header = CodegenUtils.generateFileHeader(~description=`Combined Shared and ${forkName} extensions`)
+  
+  let shared = generateSharedModule(
+    ~endpoints=sharedEndpoints,
+    ~schemas=sharedSchemas,
+    ~overrideDir?,
+    ~includeHeader=false,
+  )
+  
+  let extension = generateExtensionModule(
+    ~forkName,
+    ~endpoints=extensionEndpoints,
+    ~schemas=extensionSchemas,
+    ~overrideDir?,
+    ~includeHeader=false,
+  )
+  
+  `
+    |${header->String.trimEnd}
+    |
+    |${shared}
+    |
+    |${extension}
+    |`->CodegenUtils.trimMargin
+}
+
+let generateTagModuleFiles = (~endpoints, ~outputDir, ~wrapInModule=false, ~overrideDir=?) => {
+  let files =
+    generateAllTagModules(~endpoints, ~includeSchemas=true, ~wrapInModule, ~overrideDir?)->Array.map(((
+      tag,
+      content,
+    )) => {
+      let path = FileSystem.makePath(outputDir, `${CodegenUtils.toPascalCase(tag)}.res`)
+      ({path, content}: FileSystem.fileToWrite)
+    })
+  Pipeline.fromFilesAndWarnings(files, [])
+}
+
+let generateFlatModuleFile = (~moduleName, ~endpoints, ~outputDir, ~overrideDir=?) => {
+  let path = FileSystem.makePath(outputDir, `${moduleName}.res`)
+  let content = generateFlatModuleCode(~moduleName, ~endpoints, ~overrideDir?)
+  Pipeline.fromFile(({path, content}: FileSystem.fileToWrite))
+}
+
+let generateInstanceTagModules = (
+  ~instanceName,
+  ~modulePrefix,
+  ~endpoints,
+  ~schemas,
+  ~outputDir,
+  ~overrideDir=?,
+) => {
+  let apiDir = FileSystem.makePath(FileSystem.makePath(outputDir, instanceName), "api")
+
+  let schemaFiles = schemas->Option.mapOr([], schemaDict =>
+    if Dict.keysToArray(schemaDict)->Array.length == 0 {
+      []
+    } else {
+      let result = ComponentSchemaGenerator.generate(
+        ~spec={
+          openapi: "3.1.0",
+          info: {title: instanceName, version: "1.0.0", description: None},
+          paths: Dict.make(),
+          components: Some({schemas: Some(schemaDict)}),
+        },
+        ~outputDir=apiDir,
+      )
+      result.files->Array.map(file =>
+        if file.path->String.endsWith("ComponentSchemas.res") {
+          {
+            ...file,
+            path: file.path->String.replace(
+              "ComponentSchemas.res",
+              `${modulePrefix}ComponentSchemas.res`,
+            ),
+          }
+        } else {
+          file
+        }
+      )
+    }
+  )
+
+  let groupedByTag = OpenAPIParser.groupByTag(endpoints)
+  let endpointFiles =
+    Dict.toArray(groupedByTag)
+    ->Array.toSorted(((tagA, _), (tagB, _)) => String.compare(tagA, tagB))
+    ->Array.filterMap(((tag, tagEndpoints)) => {
+      let moduleName = `${modulePrefix}${CodegenUtils.toPascalCase(tag)}`
+      let endpointCodes = tagEndpoints->Array.flatMap(endpoint => [
+        EndpointGenerator.generateEndpointCode(endpoint, ~overrideDir?, ~moduleName, ~modulePrefix),
+        "",
+      ])
+      let content = Array.join(
+        [
+          CodegenUtils.generateFileHeader(~description=`${instanceName} API for ${tag}`),
+          "",
+          ...endpointCodes,
+        ],
+        "\n",
+      )
+      let path = FileSystem.makePath(apiDir, `${moduleName}.res`)
+      Some(({path, content}: FileSystem.fileToWrite))
+    })
+
+  Pipeline.fromFilesAndWarnings(Array.concat(schemaFiles, endpointFiles), [])
+}
+
+let generateBaseTagModules = (~baseName, ~basePrefix, ~endpoints, ~schemas, ~outputDir, ~overrideDir=?) =>
+  generateInstanceTagModules(
+    ~instanceName=baseName,
+    ~modulePrefix=basePrefix,
+    ~endpoints,
+    ~schemas,
+    ~outputDir,
+    ~overrideDir?,
+  )
+
+let generateForkTagModules = (~forkName, ~forkPrefix, ~endpoints, ~schemas, ~outputDir, ~overrideDir=?) =>
+  generateInstanceTagModules(
+    ~instanceName=forkName,
+    ~modulePrefix=forkPrefix,
+    ~endpoints,
+    ~schemas,
+    ~outputDir,
+    ~overrideDir?,
+  )
+
+let generateSeparatePerTagModules = (
+  ~baseName,
+  ~basePrefix,
+  ~forkName,
+  ~forkPrefix=None,
+  ~sharedEndpoints,
+  ~extensionEndpoints,
+  ~sharedSchemas,
+  ~extensionSchemas,
+  ~outputDir,
+  ~overrideDir=?,
+) =>
+  Pipeline.combine([
+    generateBaseTagModules(
+      ~baseName,
+      ~basePrefix,
+      ~endpoints=sharedEndpoints,
+      ~schemas=sharedSchemas,
+      ~outputDir,
+      ~overrideDir?,
+    ),
+    generateForkTagModules(
+      ~forkName,
+      ~forkPrefix=Option.getOr(forkPrefix, CodegenUtils.toPascalCase(forkName)),
+      ~endpoints=extensionEndpoints,
+      ~schemas=extensionSchemas,
+      ~outputDir,
+      ~overrideDir?,
+    ),
+  ])

package/src/generators/SchemaCodeGenerator.res

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// SchemaCodeGenerator.res - Generate complete Sury schema code with types
+
+let generateTypeCodeAndSchemaCode = (name, schema: Types.jsonSchema) => {
+  let (ir, _) = SchemaIRParser.parseJsonSchema(schema)
+  let (typeCode, _) = IRToTypeGenerator.generateNamedType(
+    ~namedSchema={name: name, description: schema.description, type_: ir},
+  )
+  let (schemaCode, _) = IRToSuryGenerator.generateNamedSchema(
+    ~namedSchema={name: `${name}Schema`, description: schema.description, type_: ir},
+  )
+  `${typeCode}\n\n${schemaCode}`
+}
+
+let generateTypeAndSchema = (name, schema) => generateTypeCodeAndSchemaCode(name, schema)
+
+let generateComponentSchemas = (components: option<Types.components>) =>
+  components
+  ->Option.flatMap(c => c.schemas)
+  ->Option.mapOr("// No component schemas\n", schemas => {
+    let sections =
+      schemas
+      ->Dict.toArray
+      ->Array.map(((name, schema)) => generateTypeCodeAndSchemaCode(name, schema))
+      ->Array.join("\n\n")
+    `// Component Schemas\n\n${sections}`
+  })
+
+let generateOperationSchemas = (operationId, operation: Types.operation) => {
+  let generatePart = (suffix, schemaOpt) =>
+    schemaOpt->Option.mapOr("", schema =>
+      generateTypeCodeAndSchemaCode(`${CodegenUtils.toPascalCase(operationId)}${suffix}`, schema)
+    )
+
+  let requestBodySchema =
+    operation.requestBody
+    ->Option.flatMap(body => body.content->Dict.get("application/json"))
+    ->Option.flatMap(mediaType => mediaType.schema)
+
+  let successResponseSchema =
+    operation.responses
+    ->(
+      responses =>
+        Dict.get(responses, "200")->Option.orElse(Dict.get(responses, "201"))
+    )
+    ->Option.flatMap(response => response.content)
+    ->Option.flatMap(content => content->Dict.get("application/json"))
+    ->Option.flatMap(mediaType => mediaType.schema)
+
+  [
+    generatePart("Request", requestBodySchema),
+    generatePart("Response", successResponseSchema),
+  ]
+  ->Array.filter(code => code != "")
+  ->Array.join("\n\n")
+}
+
+let generateEndpointModule = (path, method, operation: Types.operation) => {
+  let operationId = OpenAPIParser.getOperationId(path, method, operation)
+  let docComment = CodegenUtils.generateDocComment(
+    ~summary=?operation.summary,
+    ~description=?operation.description,
+    (),
+  )
+  let methodStr = switch method {
+  | #GET => "GET"
+  | #POST => "POST"
+  | #PUT => "PUT"
+  | #PATCH => "PATCH"
+  | #DELETE => "DELETE"
+  | #HEAD => "HEAD"
+  | #OPTIONS => "OPTIONS"
+  }
+  let schemasCode = generateOperationSchemas(operationId, operation)
+
+  `${docComment}module ${CodegenUtils.toPascalCase(operationId)} = {
+${schemasCode->CodegenUtils.indent(2)}
+
+  let endpoint = "${path}"
+  let method = #${methodStr}
+}`
+}