@f3liz/rescript-autogen-openapi 0.1.0

package/src/core/SpecDiffer.res

@@ -0,0 +1,270 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// SpecDiffer.res - Compare two OpenAPI specifications
+open Types
+
+// Helper to create endpoint keys for comparison
+let makeEndpointKey = (method: string, path: string): string => {
+  `${method}:${path}`
+}
+
+// Compare two schemas for equality (deep comparison)
+let rec schemasEqual = (schema1: jsonSchema, schema2: jsonSchema): bool => {
+  // Compare type
+  let typeMatches = switch (schema1.type_, schema2.type_) {
+  | (Some(t1), Some(t2)) => t1 == t2
+  | (None, None) => true
+  | _ => false
+  }
+  
+  if !typeMatches {
+    false
+  } else if schema1.format != schema2.format {
+    false
+  } else if schema1.nullable != schema2.nullable {
+    false
+  } else if schema1.enum != schema2.enum {
+    false
+  } else {
+    // Compare properties for objects
+    switch (schema1.properties, schema2.properties) {
+    | (Some(props1), Some(props2)) => {
+        let keys1 = Dict.keysToArray(props1)->Array.toSorted(String.compare)
+        let keys2 = Dict.keysToArray(props2)->Array.toSorted(String.compare)
+        
+        if keys1 != keys2 {
+          false
+        } else {
+          keys1->Array.every(key => {
+            switch (Dict.get(props1, key), Dict.get(props2, key)) {
+            | (Some(s1), Some(s2)) => schemasEqual(s1, s2)
+            | _ => false
+            }
+          })
+        }
+      }
+    | (None, None) => true
+    | _ => false
+    }
+  }
+}
+
+// Compare two endpoints
+let compareEndpoints = (endpoint1: endpoint, endpoint2: endpoint): option<endpointDiff> => {
+  let hasRequestBodyChanged = switch (endpoint1.requestBody, endpoint2.requestBody) {
+  | (Some(rb1), Some(rb2)) => {
+      // Compare content types
+      let keys1 = Dict.keysToArray(rb1.content)->Array.toSorted(String.compare)
+      let keys2 = Dict.keysToArray(rb2.content)->Array.toSorted(String.compare)
+      
+      if keys1 != keys2 {
+        true
+      } else {
+        keys1->Array.some(contentType => {
+          switch (Dict.get(rb1.content, contentType), Dict.get(rb2.content, contentType)) {
+          | (Some(mt1), Some(mt2)) =>
+            switch (mt1.schema, mt2.schema) {
+            | (Some(s1), Some(s2)) => !schemasEqual(s1, s2)
+            | _ => false
+            }
+          | _ => false
+          }
+        })
+      }
+    }
+  | (None, None) => false
+  | _ => true
+  }
+
+  let hasResponseChanged = {
+    let codes1 = Dict.keysToArray(endpoint1.responses)->Array.toSorted(String.compare)
+    let codes2 = Dict.keysToArray(endpoint2.responses)->Array.toSorted(String.compare)
+    
+    if codes1 != codes2 {
+      true
+    } else {
+      codes1->Array.some(code => {
+        switch (Dict.get(endpoint1.responses, code), Dict.get(endpoint2.responses, code)) {
+        | (Some(r1), Some(r2)) =>
+          switch (r1.content, r2.content) {
+          | (Some(c1), Some(c2)) => {
+              let contentKeys1 = Dict.keysToArray(c1)->Array.toSorted(String.compare)
+              let contentKeys2 = Dict.keysToArray(c2)->Array.toSorted(String.compare)
+              
+              if contentKeys1 != contentKeys2 {
+                true
+              } else {
+                contentKeys1->Array.some(contentType => {
+                  switch (Dict.get(c1, contentType), Dict.get(c2, contentType)) {
+                  | (Some(mt1), Some(mt2)) =>
+                    switch (mt1.schema, mt2.schema) {
+                    | (Some(s1), Some(s2)) => !schemasEqual(s1, s2)
+                    | _ => false
+                    }
+                  | _ => false
+                  }
+                })
+              }
+            }
+          | (None, None) => false
+          | _ => true
+          }
+        | _ => false
+        }
+      })
+    }
+  }
+
+  if hasRequestBodyChanged || hasResponseChanged {
+    Some({
+      path: endpoint1.path,
+      method: endpoint1.method,
+      requestBodyChanged: hasRequestBodyChanged,
+      responseChanged: hasResponseChanged,
+      breakingChange: hasResponseChanged, // Response changes are breaking
+    })
+  } else {
+    None
+  }
+}
+
+// Compare endpoints between two specs
+let compareEndpointLists = (
+  baseEndpoints: array<endpoint>,
+  forkEndpoints: array<endpoint>,
+): (array<endpoint>, array<endpoint>, array<endpointDiff>) => {
+  // Create maps for efficient lookup
+  let baseMap = Dict.make()
+  baseEndpoints->Array.forEach(ep => {
+    let key = makeEndpointKey(ep.method, ep.path)
+    Dict.set(baseMap, key, ep)
+  })
+
+  let forkMap = Dict.make()
+  forkEndpoints->Array.forEach(ep => {
+    let key = makeEndpointKey(ep.method, ep.path)
+    Dict.set(forkMap, key, ep)
+  })
+
+  let baseKeys = Dict.keysToArray(baseMap)->Set.fromArray
+  let forkKeys = Dict.keysToArray(forkMap)->Set.fromArray
+
+  // Find added endpoints (in fork but not in base)
+  let added = forkKeys
+    ->Set.difference(baseKeys)
+    ->Set.toArray
+    ->Array.filterMap(key => Dict.get(forkMap, key))
+
+  // Find removed endpoints (in base but not in fork)
+  let removed = baseKeys
+    ->Set.difference(forkKeys)
+    ->Set.toArray
+    ->Array.filterMap(key => Dict.get(baseMap, key))
+
+  // Find modified endpoints (in both but different)
+  let modified = baseKeys
+    ->Set.intersection(forkKeys)
+    ->Set.toArray
+    ->Array.filterMap(key => {
+      switch (Dict.get(baseMap, key), Dict.get(forkMap, key)) {
+      | (Some(baseEp), Some(forkEp)) => compareEndpoints(baseEp, forkEp)
+      | _ => None
+      }
+    })
+
+  (added, removed, modified)
+}
+
+// Compare component schemas between two specs
+let compareComponentSchemas = (
+  baseSchemas: option<dict<jsonSchema>>,
+  forkSchemas: option<dict<jsonSchema>>,
+): (array<string>, array<string>, array<schemaDiff>) => {
+  switch (baseSchemas, forkSchemas) {
+  | (None, None) => ([], [], [])
+  | (None, Some(fork)) => (Dict.keysToArray(fork), [], [])
+  | (Some(base), None) => ([], Dict.keysToArray(base), [])
+  | (Some(base), Some(fork)) => {
+      let baseKeys = Dict.keysToArray(base)->Set.fromArray
+      let forkKeys = Dict.keysToArray(fork)->Set.fromArray
+
+      // Added schemas
+      let added = forkKeys
+        ->Set.difference(baseKeys)
+        ->Set.toArray
+
+      // Removed schemas
+      let removed = baseKeys
+        ->Set.difference(forkKeys)
+        ->Set.toArray
+
+      // Modified schemas
+      let modified = baseKeys
+        ->Set.intersection(forkKeys)
+        ->Set.toArray
+        ->Array.filterMap(name => {
+          switch (Dict.get(base, name), Dict.get(fork, name)) {
+          | (Some(baseSchema), Some(forkSchema)) =>
+            if !schemasEqual(baseSchema, forkSchema) {
+              Some({
+                name: name,
+                breakingChange: true, // Schema changes are generally breaking
+              })
+            } else {
+              None
+            }
+          | _ => None
+          }
+        })
+
+      (added, removed, modified)
+    }
+  }
+}
+
+// Generate a complete diff between two specs
+let generateDiff = (
+  ~baseSpec: openAPISpec,
+  ~forkSpec: openAPISpec,
+  ~baseEndpoints: array<endpoint>,
+  ~forkEndpoints: array<endpoint>,
+): specDiff => {
+  let (addedEndpoints, removedEndpoints, modifiedEndpoints) = 
+    compareEndpointLists(baseEndpoints, forkEndpoints)
+
+  let (addedSchemas, removedSchemas, modifiedSchemas) = 
+    compareComponentSchemas(
+      baseSpec.components->Option.flatMap(c => c.schemas),
+      forkSpec.components->Option.flatMap(c => c.schemas)
+    )
+
+  {
+    addedEndpoints: addedEndpoints,
+    removedEndpoints: removedEndpoints,
+    modifiedEndpoints: modifiedEndpoints,
+    addedSchemas: addedSchemas,
+    removedSchemas: removedSchemas,
+    modifiedSchemas: modifiedSchemas,
+  }
+}
+
+// Detect if there are any breaking changes
+let hasBreakingChanges = (diff: specDiff): bool => {
+  let hasRemovedEndpoints = Array.length(diff.removedEndpoints) > 0
+  let hasBreakingEndpointChanges = diff.modifiedEndpoints
+    ->Array.some(d => d.breakingChange)
+  let hasBreakingSchemaChanges = diff.modifiedSchemas
+    ->Array.some(d => d.breakingChange)
+
+  hasRemovedEndpoints || hasBreakingEndpointChanges || hasBreakingSchemaChanges
+}
+
+// Count total changes
+let countChanges = (diff: specDiff): int => {
+  Array.length(diff.addedEndpoints) +
+  Array.length(diff.removedEndpoints) +
+  Array.length(diff.modifiedEndpoints) +
+  Array.length(diff.addedSchemas) +
+  Array.length(diff.removedSchemas) +
+  Array.length(diff.modifiedSchemas)
+}

package/src/core/SpecMerger.res

@@ -0,0 +1,245 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// SpecMerger.res - Merge base and fork OpenAPI specifications
+open Types
+
+// Helper to create endpoint key
+let makeEndpointKey = (endpoint: endpoint): string => {
+  `${endpoint.method}:${endpoint.path}`
+}
+
+// Extract shared endpoints (present in both specs with same signature)
+// For SharedBase strategy, this returns ALL base endpoints
+let extractSharedEndpoints = (
+  baseEndpoints: array<endpoint>,
+  _forkEndpoints: array<endpoint>,
+): array<endpoint> => {
+  // Return ALL base endpoints - the base should be complete
+  baseEndpoints
+}
+
+// Extract fork-specific endpoints (new AND modified endpoints)
+let extractForkExtensions = (
+  baseEndpoints: array<endpoint>,
+  forkEndpoints: array<endpoint>,
+): array<endpoint> => {
+  // Create base map for lookup
+  let baseMap = Dict.make()
+  baseEndpoints->Array.forEach(ep => {
+    let key = makeEndpointKey(ep)
+    Dict.set(baseMap, key, ep)
+  })
+
+  // Find endpoints in fork that are new OR modified
+  forkEndpoints->Array.filter(forkEp => {
+    let key = makeEndpointKey(forkEp)
+    switch Dict.get(baseMap, key) {
+    | None => true // New endpoint - include it
+    | Some(baseEp) => {
+        // Check if endpoint is modified
+        switch SpecDiffer.compareEndpoints(baseEp, forkEp) {
+        | Some(_diff) => true // Modified - include it
+        | None => false // Identical - exclude it
+        }
+      }
+    }
+  })
+}
+
+// Extract shared component schemas (ALL base schemas for SharedBase strategy)
+let extractSharedSchemas = (
+  baseSchemas: option<dict<jsonSchema>>,
+  _forkSchemas: option<dict<jsonSchema>>,
+): option<dict<jsonSchema>> => {
+  // Return ALL base schemas - the base should be complete
+  baseSchemas
+}
+
+// Extract fork-specific component schemas
+let extractForkSchemas = (
+  baseSchemas: option<dict<jsonSchema>>,
+  forkSchemas: option<dict<jsonSchema>>,
+): option<dict<jsonSchema>> => {
+  switch (baseSchemas, forkSchemas) {
+  | (_, None) => None
+  | (None, Some(fork)) => Some(fork) // All fork schemas are extensions
+  | (Some(base), Some(fork)) => {
+      let extensions = Dict.make()
+      
+      Dict.keysToArray(fork)->Array.forEach(name => {
+        switch (Dict.get(base, name), Dict.get(fork, name)) {
+        | (None, Some(forkSchema)) => {
+            // New schema in fork
+            Dict.set(extensions, name, forkSchema)
+          }
+        | (Some(baseSchema), Some(forkSchema)) => {
+            // Check if modified
+            if !SpecDiffer.schemasEqual(baseSchema, forkSchema) {
+              Dict.set(extensions, name, forkSchema)
+            }
+          }
+        | _ => ()
+        }
+      })
+      
+      if Dict.keysToArray(extensions)->Array.length > 0 {
+        Some(extensions)
+      } else {
+        None
+      }
+    }
+  }
+}
+
+// Create a new spec with given endpoints
+let createSpecWithEndpoints = (
+  ~baseSpec: openAPISpec,
+  ~endpoints: array<endpoint>,
+  ~schemas: option<dict<jsonSchema>>,
+): openAPISpec => {
+  // Group endpoints by path
+  let pathsDict = Dict.make()
+  
+  endpoints->Array.forEach(ep => {
+    let pathItem = switch Dict.get(pathsDict, ep.path) {
+    | Some(existing) => existing
+    | None => {
+        get: None,
+        post: None,
+        put: None,
+        delete: None,
+        patch: None,
+        head: None,
+        options: None,
+        parameters: None,
+      }
+    }
+    
+    let operation: operation = {
+      operationId: ep.operationId,
+      summary: ep.summary,
+      description: ep.description,
+      tags: ep.tags,
+      parameters: ep.parameters,
+      requestBody: ep.requestBody,
+      responses: ep.responses,
+    }
+    
+    let updatedPathItem = switch String.toLowerCase(ep.method) {
+    | "get" => {...pathItem, get: Some(operation)}
+    | "post" => {...pathItem, post: Some(operation)}
+    | "put" => {...pathItem, put: Some(operation)}
+    | "delete" => {...pathItem, delete: Some(operation)}
+    | "patch" => {...pathItem, patch: Some(operation)}
+    | _ => pathItem
+    }
+    
+    Dict.set(pathsDict, ep.path, updatedPathItem)
+  })
+  
+  // Update components with schemas
+  let components = switch (baseSpec.components, schemas) {
+  | (Some(_comp), Some(sch)) => Some({schemas: Some(sch)})
+  | (Some(_comp), None) => Some({schemas: None})
+  | (None, Some(sch)) => Some({
+      schemas: Some(sch),
+    })
+  | (None, None) => None
+  }
+  
+  {
+    ...baseSpec,
+    paths: pathsDict,
+    components: components,
+  }
+}
+
+// Merge two specs using SharedBase strategy
+let mergeWithSharedBase = (
+  ~baseSpec: openAPISpec,
+  ~forkSpec: openAPISpec,
+  ~baseEndpoints: array<endpoint>,
+  ~forkEndpoints: array<endpoint>,
+): (openAPISpec, openAPISpec) => {
+  // Extract shared and fork-specific endpoints
+  let sharedEndpoints = extractSharedEndpoints(baseEndpoints, forkEndpoints)
+  let forkExtensions = extractForkExtensions(baseEndpoints, forkEndpoints)
+  
+  // Extract shared and fork-specific schemas
+  let baseSchemas = baseSpec.components->Option.flatMap(c => c.schemas)
+  let forkSchemas = forkSpec.components->Option.flatMap(c => c.schemas)
+  
+  let sharedSchemas = extractSharedSchemas(baseSchemas, forkSchemas)
+  let extensionSchemas = extractForkSchemas(baseSchemas, forkSchemas)
+  
+  // Create shared spec
+  let sharedSpec = createSpecWithEndpoints(
+    ~baseSpec=baseSpec,
+    ~endpoints=sharedEndpoints,
+    ~schemas=sharedSchemas,
+  )
+  
+  // Create fork extensions spec
+  let extensionsSpec = createSpecWithEndpoints(
+    ~baseSpec=forkSpec,
+    ~endpoints=forkExtensions,
+    ~schemas=extensionSchemas,
+  )
+  
+  (sharedSpec, extensionsSpec)
+}
+
+// Merge two specs using Separate strategy (keep both complete)
+let mergeWithSeparate = (
+  ~baseSpec: openAPISpec,
+  ~forkSpec: openAPISpec,
+): (openAPISpec, openAPISpec) => {
+  // No merging, just return both specs as-is
+  (baseSpec, forkSpec)
+}
+
+// Merge specs according to strategy
+let mergeSpecs = (
+  ~baseSpec: openAPISpec,
+  ~forkSpec: openAPISpec,
+  ~baseEndpoints: array<endpoint>,
+  ~forkEndpoints: array<endpoint>,
+  ~strategy: generationStrategy,
+): (openAPISpec, openAPISpec) => {
+  switch strategy {
+  | Separate => mergeWithSeparate(~baseSpec, ~forkSpec)
+  | SharedBase =>
+      mergeWithSharedBase(~baseSpec, ~forkSpec, ~baseEndpoints, ~forkEndpoints)
+  }
+}
+
+// Calculate merge statistics
+type mergeStats = {
+  sharedEndpointCount: int,
+  forkExtensionCount: int,
+  sharedSchemaCount: int,
+  forkSchemaCount: int,
+}
+
+let getMergeStats = (
+  ~baseEndpoints: array<endpoint>,
+  ~forkEndpoints: array<endpoint>,
+  ~baseSchemas: option<dict<jsonSchema>>,
+  ~forkSchemas: option<dict<jsonSchema>>,
+): mergeStats => {
+  let shared = extractSharedEndpoints(baseEndpoints, forkEndpoints)
+  let extensions = extractForkExtensions(baseEndpoints, forkEndpoints)
+  let sharedSchemas = extractSharedSchemas(baseSchemas, forkSchemas)
+  let extensionSchemas = extractForkSchemas(baseSchemas, forkSchemas)
+  
+  {
+    sharedEndpointCount: Array.length(shared),
+    forkExtensionCount: Array.length(extensions),
+    sharedSchemaCount: sharedSchemas->Option.mapOr(0, s => 
+      Dict.keysToArray(s)->Array.length
+    ),
+    forkSchemaCount: extensionSchemas->Option.mapOr(0, s => 
+      Dict.keysToArray(s)->Array.length
+    ),
+  }
+}

package/src/generators/ComponentSchemaGenerator.res

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// ComponentSchemaGenerator.res - Generate shared component schema module
+open Types
+
+let rec extractReferencedSchemaNames = (irType: SchemaIR.irType) =>
+  switch irType {
+  | Reference(ref) =>
+    let parts = ref->String.split("/")
+    [parts->Array.get(parts->Array.length - 1)->Option.getOr("")]
+  | Array({items}) => extractReferencedSchemaNames(items)
+  | Object({properties}) => properties->Array.flatMap(((_name, fieldType, _)) => extractReferencedSchemaNames(fieldType))
+  | Union(types)
+  | Intersection(types) =>
+    types->Array.flatMap(extractReferencedSchemaNames)
+  | Option(inner) => extractReferencedSchemaNames(inner)
+  | _ => []
+  }
+
+let generate = (~spec, ~outputDir) => {
+  let (context, parseWarnings) =
+    spec.components
+    ->Option.flatMap(components => components.schemas)
+    ->Option.mapOr(({SchemaIR.schemas: Dict.make()}, []), schemas =>
+      SchemaIRParser.parseComponentSchemas(schemas)
+    )
+
+  if Dict.size(context.schemas) == 0 {
+    Pipeline.empty
+  } else {
+    let schemas = Dict.valuesToArray(context.schemas)
+    let schemaNameMap = Dict.fromArray(schemas->Array.map(s => (s.name, s)))
+
+    // Map each schema to its internal dependencies (other schemas in the same spec)
+    let dependencyMap = schemas->Array.reduce(Dict.make(), (acc, schema) => {
+      let references =
+        extractReferencedSchemaNames(schema.type_)->Array.filter(name =>
+          Dict.has(schemaNameMap, name) && name != schema.name
+        )
+      Dict.set(acc, schema.name, references)
+      acc
+    })
+
+    // Topological sort (Kahn's algorithm) to handle schema dependencies
+    let sortedSchemas = []
+    let inDegreeMap = schemas->Array.reduce(Dict.make(), (acc, schema) => {
+      let degree = Dict.get(dependencyMap, schema.name)->Option.mapOr(0, Array.length)
+      Dict.set(acc, schema.name, degree)
+      acc
+    })
+
+    let queue = schemas->Array.filter(schema => Dict.get(inDegreeMap, schema.name)->Option.getOr(0) == 0)
+
+    while Array.length(queue) > 0 {
+      let schema = switch Array.shift(queue) {
+      | Some(v) => v
+      | None => schemas->Array.getUnsafe(0) // Should not happen
+      }
+      sortedSchemas->Array.push(schema)
+
+      schemas->Array.forEach(otherSchema => {
+        let dependsOnCurrent =
+          Dict.get(dependencyMap, otherSchema.name)
+          ->Option.getOr([])
+          ->Array.some(name => name == schema.name)
+
+        if dependsOnCurrent {
+          let currentDegree = Dict.get(inDegreeMap, otherSchema.name)->Option.getOr(0)
+          let newDegree = currentDegree - 1
+          Dict.set(inDegreeMap, otherSchema.name, newDegree)
+          if newDegree == 0 {
+            queue->Array.push(otherSchema)
+          }
+        }
+      })
+    }
+
+    // Ensure all schemas are included even if there's a circular dependency
+    let sortedNames = sortedSchemas->Array.map(s => s.name)
+    let remainingSchemas =
+      schemas
+      ->Array.filter(s => !(sortedNames->Array.some(name => name == s.name)))
+      ->Array.toSorted((a, b) => String.compare(a.name, b.name))
+
+    let finalSortedSchemas = Array.concat(sortedSchemas, remainingSchemas)
+    let availableSchemaNames = finalSortedSchemas->Array.map(s => s.name)
+    let warnings = Array.copy(parseWarnings)
+
+    let moduleCodes = finalSortedSchemas->Array.map(schema => {
+      let typeCtx = GenerationContext.make(
+        ~path=`ComponentSchemas.${schema.name}`,
+        ~insideComponentSchemas=true,
+        ~availableSchemas=availableSchemaNames,
+        (),
+      )
+      let schemaCtx = GenerationContext.make(
+        ~path=`ComponentSchemas.${schema.name}`,
+        ~insideComponentSchemas=true,
+        ~availableSchemas=availableSchemaNames,
+        (),
+      )
+
+      let typeCode = IRToTypeGenerator.generateTypeWithContext(~ctx=typeCtx, ~depth=0, schema.type_)
+      let schemaCode = IRToSuryGenerator.generateSchemaWithContext(~ctx=schemaCtx, ~depth=0, schema.type_)
+
+      warnings->Array.pushMany(typeCtx.warnings)
+      warnings->Array.pushMany(schemaCtx.warnings)
+
+      let docComment = schema.description->Option.mapOr("", d =>
+        CodegenUtils.generateDocString(~description=d, ())
+      )
+
+      `${docComment}module ${CodegenUtils.toPascalCase(schema.name)} = {
+  type t = ${typeCode}
+  let schema = ${schemaCode}
+}`
+    })
+
+    let fileHeader = CodegenUtils.generateFileHeader(~description="Shared component schemas")
+    let fileContent = `${fileHeader}\n\n${moduleCodes->Array.join("\n\n")}`
+
+    Pipeline.fromFilesAndWarnings(
+      [{path: FileSystem.makePath(outputDir, "ComponentSchemas.res"), content: fileContent}],
+      warnings,
+    )
+  }
+}