@f3liz/rescript-autogen-openapi 0.1.0

package/src/core/OpenAPIParser.res

@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// OpenAPIParser.res - Parse OpenAPI 3.1 specs
+
+// Parse HTTP method from string
+let parseMethod = (methodStr: string): option<Types.httpMethod> => {
+  switch methodStr->String.toLowerCase {
+  | "get" => Some(#GET)
+  | "post" => Some(#POST)
+  | "put" => Some(#PUT)
+  | "patch" => Some(#PATCH)
+  | "delete" => Some(#DELETE)
+  | "head" => Some(#HEAD)
+  | "options" => Some(#OPTIONS)
+  | _ => None
+  }
+}
+
+// Convert httpMethod to string
+let httpMethodToString = (method: Types.httpMethod): string => {
+  switch method {
+  | #GET => "get"
+  | #POST => "post"
+  | #PUT => "put"
+  | #PATCH => "patch"
+  | #DELETE => "delete"
+  | #HEAD => "head"
+  | #OPTIONS => "options"
+  }
+}
+
+// Convert tuple to endpoint
+let tupleToEndpoint = ((path, method, operation): (string, Types.httpMethod, Types.operation)): Types.endpoint => {
+  {
+    path,
+    method: httpMethodToString(method),
+    operationId: operation.operationId,
+    summary: operation.summary,
+    description: operation.description,
+    tags: operation.tags,
+    requestBody: operation.requestBody,
+    responses: operation.responses,
+    parameters: operation.parameters,
+  }
+}
+
+// Extract operations from a path item
+let getOperations = (path: string, {get, post, put, patch, delete, head, options}: Types.pathItem): array<(string, Types.httpMethod, Types.operation)> => {
+  [
+    (#GET, get),
+    (#POST, post),
+    (#PUT, put),
+    (#PATCH, patch),
+    (#DELETE, delete),
+    (#HEAD, head),
+    (#OPTIONS, options),
+  ]->Array.filterMap(((method, op)) => op->Option.map(op => (path, method, op)))
+}
+
+// Get all endpoints from the spec
+let getAllEndpoints = (spec: Types.openAPISpec): array<Types.endpoint> => {
+  let pathsArray = spec.paths->Dict.toArray
+  
+  pathsArray
+  ->Array.flatMap(((path, pathItem)) => getOperations(path, pathItem))
+  ->Array.map(tupleToEndpoint)
+}
+
+// Group endpoints by tag
+let groupByTag = (
+  endpoints: array<Types.endpoint>
+): Dict.t<array<Types.endpoint>> => {
+  let grouped = Dict.make()
+  
+  endpoints->Array.forEach(endpoint => {
+    let tags = endpoint.tags->Option.getOr(["default"])
+    
+    tags->Array.forEach(tag => {
+      let existing = grouped->Dict.get(tag)->Option.getOr([])
+      existing->Array.push(endpoint)
+      grouped->Dict.set(tag, existing)
+    })
+  })
+  
+  grouped
+}
+
+// Get all schemas from components
+let getAllSchemas = (spec: Types.openAPISpec): Dict.t<Types.jsonSchema> => {
+  spec.components
+  ->Option.flatMap(c => c.schemas)
+  ->Option.getOr(Dict.make())
+}
+
+// Extract operation ID or generate one
+let getOperationId = (path: string, method: Types.httpMethod, operation: Types.operation): string => {
+  operation.operationId->Option.getOr({
+    // Generate operation ID from path and method
+    let methodStr = switch method {
+    | #GET => "get"
+    | #POST => "post"
+    | #PUT => "put"
+    | #PATCH => "patch"
+    | #DELETE => "delete"
+    | #HEAD => "head"
+    | #OPTIONS => "options"
+    }
+    
+    let pathParts = path
+      ->String.replaceAll("/", "_")
+      ->String.replaceAll("{", "")
+      ->String.replaceAll("}", "")
+      ->String.replaceAll("-", "_")
+    
+    `${methodStr}${pathParts}`
+  })
+}
+
+// Filter endpoints by tags
+let filterByTags = (
+  ~endpoints: array<Types.endpoint>,
+  ~includeTags: array<string>,
+  ~excludeTags: array<string>,
+): array<Types.endpoint> => {
+  endpoints->Array.filter(endpoint => {
+    let operationTags = endpoint.tags->Option.getOr([])
+    
+    // Check include tags
+    let included = operationTags->Array.some(tag => includeTags->Array.includes(tag))
+    
+    // Check exclude tags
+    let excluded = operationTags->Array.some(tag => excludeTags->Array.includes(tag))
+    
+    included && !excluded
+  })
+}
+
+// Get unique tags from all endpoints
+let getAllTags = (endpoints: array<Types.endpoint>): array<string> => {
+  endpoints
+  ->Array.flatMap(endpoint => endpoint.tags->Option.getOr([]))
+  ->Set.fromArray
+  ->Set.toArray
+}

package/src/core/Pipeline.res

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// Pipeline.res - Compact data transformation pipeline
+open Types
+
+type t = {
+  files: array<FileSystem.fileToWrite>,
+  warnings: array<warning>,
+}
+
+let empty = {files: [], warnings: []}
+
+// Combine two pipelines
+let merge = (a, b) => {
+  files: Array.concat(a.files, b.files),
+  warnings: Array.concat(a.warnings, b.warnings),
+}
+
+// Pipe-first API
+let combine = outputs => {
+  files: outputs->Array.flatMap(p => p.files),
+  warnings: outputs->Array.flatMap(p => p.warnings),
+}
+
+let addFile = (file, p) => {...p, files: Array.concat(p.files, [file])}
+let addFiles = (files, p) => {...p, files: Array.concat(p.files, files)}
+let addWarning = (warning, p) => {...p, warnings: Array.concat(p.warnings, [warning])}
+let addWarnings = (warnings, p) => {...p, warnings: Array.concat(p.warnings, warnings)}
+
+let mapFiles = (fn, p) => {...p, files: p.files->Array.map(fn)}
+let filterWarnings = (pred, p) => {...p, warnings: p.warnings->Array.filter(pred)}
+
+// Constructors
+let make = (~files=[], ~warnings=[], ()) => {files, warnings}
+let fromFile = file => make(~files=[file], ())
+let fromFiles = files => make(~files, ())
+let fromWarning = warning => make(~warnings=[warning], ())
+let fromWarnings = warnings => make(~warnings, ())
+
+// Accessors
+let files = p => p.files
+let warnings = p => p.warnings
+let fileCount = p => Array.length(p.files)
+let warningCount = p => Array.length(p.warnings)
+let filePaths = p => p.files->Array.map(f => f.path)
+
+// Legacy aliases for compatibility during migration
+type generationOutput = t
+let withWarnings = (p, w) => addWarnings(w, p)
+let withFiles = (p, f) => addFiles(f, p)
+let fromFilesAndWarnings = (files, warnings) => make(~files, ~warnings, ())

package/src/core/ReferenceResolver.res

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// ReferenceResolver.res - Utilities for resolving component schema references
+
+// Convert a reference like "#/components/schemas/User" to module path
+// If insideComponentSchemas=true, returns "User.t" (relative)
+// If insideComponentSchemas=false, returns "{prefix}ComponentSchemas.User.t" (fully qualified)
+let refToTypePath = (~insideComponentSchemas=false, ~modulePrefix="", ref: string): option<string> => {
+  // Handle #/components/schemas/SchemaName format
+  let parts = ref->String.split("/")
+  switch parts->Array.get(parts->Array.length - 1) {
+  | None => None
+  | Some(schemaName) => {
+      let moduleName = CodegenUtils.toPascalCase(schemaName)
+      if insideComponentSchemas {
+        Some(`${moduleName}.t`)
+      } else {
+        Some(`${modulePrefix}ComponentSchemas.${moduleName}.t`)
+      }
+    }
+  }
+}
+
+// Convert a reference like "#/components/schemas/User" to schema path
+// If insideComponentSchemas=true, returns "User.schema" (relative)
+// If insideComponentSchemas=false, returns "{prefix}ComponentSchemas.User.schema" (fully qualified)
+let refToSchemaPath = (~insideComponentSchemas=false, ~modulePrefix="", ref: string): option<string> => {
+  // Handle #/components/schemas/SchemaName format
+  let parts = ref->String.split("/")
+  switch parts->Array.get(parts->Array.length - 1) {
+  | None => None
+  | Some(schemaName) => {
+      let moduleName = CodegenUtils.toPascalCase(schemaName)
+      if insideComponentSchemas {
+        Some(`${moduleName}.schema`)
+      } else {
+        Some(`${modulePrefix}ComponentSchemas.${moduleName}.schema`)
+      }
+    }
+  }
+}

package/src/core/Result.res

@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// Result.res - Railway-oriented programming helpers
+// Compact utilities for elegant error handling with pipe-first style
+
+// Re-export core Result for convenience
+include Result
+
+// Applicative-style combinators  
+let map2 = (ra, rb, f) =>
+  switch (ra, rb) {
+  | (Ok(a), Ok(b)) => Ok(f(a, b))
+  | (Error(e), _) => Error(e)
+  | (_, Error(e)) => Error(e)
+  }
+
+let map3 = (ra, rb, rc, f) =>
+  switch (ra, rb, rc) {
+  | (Ok(a), Ok(b), Ok(c)) => Ok(f(a, b, c))
+  | (Error(e), _, _) => Error(e)
+  | (_, Error(e), _) => Error(e)
+  | (_, _, Error(e)) => Error(e)
+  }
+
+let map4 = (ra, rb, rc, rd, f) =>
+  switch (ra, rb, rc, rd) {
+  | (Ok(a), Ok(b), Ok(c), Ok(d)) => Ok(f(a, b, c, d))
+  | (Error(e), _, _, _) => Error(e)
+  | (_, Error(e), _, _) => Error(e)
+  | (_, _, Error(e), _) => Error(e)
+  | (_, _, _, Error(e)) => Error(e)
+  }
+
+// Collect array of results into result of array
+let all = results => {
+  let acc = []
+  let error = ref(None)
+  let len = Array.length(results)
+  
+  let rec loop = idx => {
+    if idx < len && Option.isNone(error.contents) {
+      switch Array.getUnsafe(results, idx) {
+      | Ok(v) => {
+          Array.push(acc, v)
+          loop(idx + 1)
+        }
+      | Error(e) => error := Some(e)
+      }
+    }
+  }
+  
+  loop(0)
+  
+  switch error.contents {
+  | Some(e) => Error(e)
+  | None => Ok(acc)
+  }
+}
+
+// Collect results, ignoring successful values (just check for errors)
+let allUnit = results => {
+  let error = ref(None)
+  let len = Array.length(results)
+  
+  let rec loop = idx => {
+    if idx < len && Option.isNone(error.contents) {
+      switch Array.getUnsafe(results, idx) {
+      | Ok(_) => loop(idx + 1)
+      | Error(e) => error := Some(e)
+      }
+    }
+  }
+  
+  loop(0)
+  
+  switch error.contents {
+  | Some(e) => Error(e)
+  | None => Ok()
+  }
+}
+
+// Partition results into successes and errors
+let partition = results => {
+  let successes = []
+  let errors = []
+  results->Array.forEach(r =>
+    switch r {
+    | Ok(v) => successes->Array.push(v)
+    | Error(e) => errors->Array.push(e)
+    }
+  )
+  (successes, errors)
+}
+
+// Try multiple computations, return first success or all errors
+let firstSuccess = results => {
+  let errors = []
+  let success = ref(None)
+  let len = Array.length(results)
+  
+  let rec loop = idx => {
+    if idx < len && Option.isNone(success.contents) {
+      switch Array.getUnsafe(results, idx) {
+      | Ok(v) => success := Some(v)
+      | Error(e) => {
+          Array.push(errors, e)
+          loop(idx + 1)
+        }
+      }
+    }
+  }
+  
+  loop(0)
+  
+  switch success.contents {
+  | Some(v) => Ok(v)
+  | None => Error(errors)
+  }
+}
+
+// Fold with early exit on error
+let foldM = (arr, init, f) => {
+  let rec loop = (acc, idx) =>
+    if idx >= Array.length(arr) {
+      Ok(acc)
+    } else {
+      f(acc, arr->Array.getUnsafe(idx))->flatMap(newAcc => loop(newAcc, idx + 1))
+    }
+  loop(init, 0)
+}
+
+// Tap for side effects (useful for logging)
+let tap = (result, f) => {
+  switch result {
+  | Ok(v) => f(v)
+  | Error(_) => ()
+  }
+  result
+}
+
+let tapError = (result, f) => {
+  switch result {
+  | Error(e) => f(e)
+  | Ok(_) => ()
+  }
+  result
+}
+
+// Convert option to result
+let fromOption = (opt, error) =>
+  switch opt {
+  | Some(v) => Ok(v)
+  | None => Error(error)
+  }
+
+// Convert to option (discarding error)
+let toOption = result =>
+  switch result {
+  | Ok(v) => Some(v)
+  | Error(_) => None
+  }
+
+// Recover from error with a function
+let recover = (result, f) =>
+  switch result {
+  | Ok(_) as ok => ok
+  | Error(e) => f(e)
+  }
+
+// Pipe-first versions of common operations
+let getOr = (result, default) =>
+  switch result {
+  | Ok(v) => v
+  | Error(_) => default
+  }
+
+let getExn = result =>
+  switch result {
+  | Ok(v) => v
+  | Error(_) => panic("Result.getExn called on Error")
+  }
+
+let getError = result =>
+  switch result {
+  | Ok(_) => None
+  | Error(e) => Some(e)
+  }

package/src/core/SchemaIR.res

@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// SchemaIR.res - Unified Intermediate Representation for JSON Schema
+// This IR abstracts away JSON Schema details and provides a clean representation
+// that can be used to generate both ReScript types and Sury schemas
+
+// Validation constraints
+type stringConstraints = {
+  minLength: option<int>,
+  maxLength: option<int>,
+  pattern: option<string>,
+}
+
+type numberConstraints = {
+  minimum: option<float>,
+  maximum: option<float>,
+  multipleOf: option<float>,
+}
+
+type arrayConstraints = {
+  minItems: option<int>,
+  maxItems: option<int>,
+  uniqueItems: bool,
+}
+
+// Core IR types
+type rec irType =
+  | String({constraints: stringConstraints})
+  | Number({constraints: numberConstraints})
+  | Integer({constraints: numberConstraints})
+  | Boolean
+  | Null
+  | Array({items: irType, constraints: arrayConstraints})
+  | Object({
+      properties: array<(string, irType, bool)>, // (name, type, required)
+      additionalProperties: option<irType>,
+    })
+  | Literal(literalValue)
+  | Union(array<irType>)
+  | Intersection(array<irType>)
+  | Reference(string) // Schema reference like "#/components/schemas/User"
+  | Option(irType) // Nullable/optional types
+  | Unknown
+
+and literalValue =
+  | StringLiteral(string)
+  | NumberLiteral(float)
+  | BooleanLiteral(bool)
+  | NullLiteral
+
+// Named schema definition
+type namedSchema = {
+  name: string,
+  description: option<string>,
+  type_: irType,
+}
+
+// Schema context for resolving references
+type schemaContext = {
+  schemas: Dict.t<namedSchema>,
+}
+
+// Helpers
+let isOptional = (irType: irType): bool => {
+  switch irType {
+  | Option(_) => true
+  | _ => false
+  }
+}
+
+let unwrapOption = (irType: irType): irType => {
+  switch irType {
+  | Option(inner) => inner
+  | other => other
+  }
+}
+
+let makeOptional = (irType: irType): irType => {
+  switch irType {
+  | Option(_) => irType // Already optional
+  | other => Option(other)
+  }
+}
+
+// Check if a type is simple (no complex nested structures)
+let rec isSimpleType = (irType: irType): bool => {
+  switch irType {
+  | String(_) | Number(_) | Integer(_) | Boolean | Null | Reference(_) => true
+  | Option(inner) => isSimpleType(inner)
+  | Literal(_) => true
+  | Array({items, _}) => isSimpleType(items)
+  | Object(_) | Union(_) | Intersection(_) | Unknown => false
+  }
+}
+
+// Count the complexity of a type (for deciding whether to inline or extract)
+let rec complexityScore = (irType: irType): int => {
+  switch irType {
+  | String(_) | Number(_) | Integer(_) | Boolean | Null | Reference(_) | Literal(_) => 1
+  | Option(inner) => complexityScore(inner)
+  | Array({items, _}) => 1 + complexityScore(items)
+  | Object({properties, _}) => {
+      let propsScore = properties
+        ->Array.map(((_, type_, _)) => complexityScore(type_))
+        ->Array.reduce(0, (acc, score) => acc + score)
+      5 + propsScore // Objects are inherently complex
+    }
+  | Union(types) => {
+      let typesScore = types
+        ->Array.map(complexityScore)
+        ->Array.reduce(0, (acc, score) => acc + score)
+      2 + typesScore
+    }
+  | Intersection(types) => {
+      let typesScore = types
+        ->Array.map(complexityScore)
+        ->Array.reduce(0, (acc, score) => acc + score)
+      3 + typesScore
+    }
+  | Unknown => 1
+  }
+}
+
+// Extract nested complex types that should be named separately
+// Returns (simplified type, extracted schemas)
+let rec extractComplexTypes = (
+  ~baseName: string,
+  ~irType: irType,
+  ~threshold: int=10,
+): (irType, array<namedSchema>) => {
+  let score = complexityScore(irType)
+  
+  if score <= threshold {
+    (irType, [])
+  } else {
+    switch irType {
+    | Object({properties, additionalProperties}) => {
+        // Extract complex property types
+        let (newProperties, allExtracted) = properties
+          ->Array.map(((propName, propType, required)) => {
+            let propBaseName = `${baseName}_${propName}`
+            let (newType, extracted) = extractComplexTypes(
+              ~baseName=propBaseName,
+              ~irType=propType,
+              ~threshold,
+            )
+            ((propName, newType, required), extracted)
+          })
+          ->Array.reduce(([], []), ((props, allExtr), ((prop, extracted))) => {
+            (Array.concat(props, [prop]), Array.concat(allExtr, extracted))
+          })
+        
+        let newType = Object({
+          properties: newProperties,
+          additionalProperties,
+        })
+        
+        (Reference(`#/components/schemas/${baseName}`), Array.concat(allExtracted, [{
+          name: baseName,
+          description: None,
+          type_: newType,
+        }]))
+      }
+    | Array({items, constraints}) => {
+        let (newItems, extracted) = extractComplexTypes(
+          ~baseName=`${baseName}_Item`,
+          ~irType=items,
+          ~threshold,
+        )
+        (Array({items: newItems, constraints}), extracted)
+      }
+    | Union(types) => {
+        let (newTypes, allExtracted) = types
+          ->Array.mapWithIndex((type_, i) => {
+            extractComplexTypes(
+              ~baseName=`${baseName}_Variant${Int.toString(i)}`,
+              ~irType=type_,
+              ~threshold,
+            )
+          })
+          ->Array.reduce(([], []), ((types, allExtr), ((type_, extracted))) => {
+            (Array.concat(types, [type_]), Array.concat(allExtr, extracted))
+          })
+        (Union(newTypes), allExtracted)
+      }
+    | Option(inner) => {
+        let (newInner, extracted) = extractComplexTypes(
+          ~baseName,
+          ~irType=inner,
+          ~threshold,
+        )
+        (Option(newInner), extracted)
+      }
+    | other => (other, [])
+    }
+  }
+}
+
+// Check if two IR types are equal (shallow comparison for T | Array<T> detection)
+let rec equals = (a: irType, b: irType): bool => {
+  switch (a, b) {
+  | (String(_), String(_)) => true
+  | (Number(_), Number(_)) => true
+  | (Integer(_), Integer(_)) => true
+  | (Boolean, Boolean) => true
+  | (Null, Null) => true
+  | (Array({items: itemsA, _}), Array({items: itemsB, _})) => equals(itemsA, itemsB)
+  | (Reference(refA), Reference(refB)) => refA == refB
+  | (Option(innerA), Option(innerB)) => equals(innerA, innerB)
+  | (Literal(litA), Literal(litB)) => {
+      switch (litA, litB) {
+      | (StringLiteral(a), StringLiteral(b)) => a == b
+      | (NumberLiteral(a), NumberLiteral(b)) => a == b
+      | (BooleanLiteral(a), BooleanLiteral(b)) => a == b
+      | (NullLiteral, NullLiteral) => true
+      | _ => false
+      }
+    }
+  | (Unknown, Unknown) => true
+  | _ => false
+  }
+}
+
+// Pretty print IR type for debugging
+let rec toString = (irType: irType): string => {
+  switch irType {
+  | String(_) => "String"
+  | Number(_) => "Number"
+  | Integer(_) => "Integer"
+  | Boolean => "Boolean"
+  | Null => "Null"
+  | Array({items, _}) => `Array<${toString(items)}>`
+  | Object({properties, _}) => {
+      let props = properties
+        ->Array.map(((name, type_, required)) => {
+          let req = required ? "" : "?"
+          `${name}${req}: ${toString(type_)}`
+        })
+        ->Array.join(", ")
+      `{ ${props} }`
+    }
+  | Literal(StringLiteral(s)) => `"${s}"`
+  | Literal(NumberLiteral(n)) => Float.toString(n)
+  | Literal(BooleanLiteral(b)) => b ? "true" : "false"
+  | Literal(NullLiteral) => "null"
+  | Union(types) => {
+      let typeStrs = types->Array.map(toString)->Array.join(" | ")
+      `(${typeStrs})`
+    }
+  | Intersection(types) => {
+      let typeStrs = types->Array.map(toString)->Array.join(" & ")
+      `(${typeStrs})`
+    }
+  | Reference(ref) => ref
+  | Option(inner) => `Option<${toString(inner)}>`
+  | Unknown => "Unknown"
+  }
+}