@f3liz/rescript-autogen-openapi 0.2.0 → 0.3.0

package/lib/es6/src/generators/ComponentSchemaGenerator.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Pipeline from "../core/Pipeline.mjs";
+import * as Toposort from "../bindings/Toposort.mjs";
 import * as FileSystem from "../core/FileSystem.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as CodegenUtils from "../core/CodegenUtils.mjs";
@@ -29,8 +30,7 @@ function extractReferencedSchemaNames(_irType) {
       case "Intersection" :
         return irType._0.flatMap(extractReferencedSchemaNames);
       case "Reference" :
-        let parts = irType._0.split("/");
-        return [Stdlib_Option.getOr(parts[parts.length - 1 | 0], "")];
+        return [irType._0];
       case "Option" :
         _irType = irType._0;
         continue;
@@ -56,7 +56,8 @@ function generate(spec, outputDir) {
     s.name,
     s
   ]));
-  let dependencyMap = Stdlib_Array.reduce(schemas, {}, (acc, schema) => {
+  let allNodes = schemas.map(s => s.name);
+  let edges = schemas.flatMap(schema => {
     let references = extractReferencedSchemaNames(schema.type_).filter(name => {
       if (name in schemaNameMap) {
         return name !== schema.name;
@@ -64,50 +65,131 @@ function generate(spec, outputDir) {
         return false;
       }
     });
-    acc[schema.name] = references;
-    return acc;
+    return references.map(dep => [
+      schema.name,
+      dep
+    ]);
   });
-  let sortedSchemas = [];
-  let inDegreeMap = Stdlib_Array.reduce(schemas, {}, (acc, schema) => {
-    let degree = Stdlib_Option.mapOr(dependencyMap[schema.name], 0, prim => prim.length);
-    acc[schema.name] = degree;
-    return acc;
-  });
-  let queue = schemas.filter(schema => Stdlib_Option.getOr(inDegreeMap[schema.name], 0) === 0);
-  while (queue.length !== 0) {
-    let v = queue.shift();
-    let schema = v !== undefined ? v : schemas[0];
-    sortedSchemas.push(schema);
-    schemas.forEach(otherSchema => {
-      let dependsOnCurrent = Stdlib_Option.getOr(dependencyMap[otherSchema.name], []).some(name => name === schema.name);
-      if (!dependsOnCurrent) {
+  let sortedNames;
+  try {
+    sortedNames = Toposort.sortArray(allNodes, edges).toReversed();
+  } catch (exn) {
+    let visited = {};
+    let inStack = {};
+    let cycleEdges = [];
+    let dfs = node => {
+      if (Stdlib_Option.getOr(inStack[node], false) || Stdlib_Option.getOr(visited[node], false)) {
         return;
-      }
-      let currentDegree = Stdlib_Option.getOr(inDegreeMap[otherSchema.name], 0);
-      let newDegree = currentDegree - 1 | 0;
-      inDegreeMap[otherSchema.name] = newDegree;
-      if (newDegree === 0) {
-        queue.push(otherSchema);
+      } else {
+        visited[node] = true;
+        inStack[node] = true;
+        edges.forEach(param => {
+          let from = param[0];
+          if (from !== node) {
+            return;
+          }
+          let to = param[1];
+          if (Stdlib_Option.getOr(inStack[to], false)) {
+            cycleEdges.push([
+              from,
+              to
+            ]);
+            return;
+          } else {
+            return dfs(to);
+          }
+        });
+        inStack[node] = false;
         return;
       }
+    };
+    allNodes.forEach(dfs);
+    let nonCycleEdges = edges.filter(param => {
+      let to = param[1];
+      let from = param[0];
+      return !cycleEdges.some(param => {
+        if (param[0] === from) {
+          return param[1] === to;
+        } else {
+          return false;
+        }
+      });
     });
-  };
-  let sortedNames = sortedSchemas.map(s => s.name);
-  let remainingSchemas = schemas.filter(s => !sortedNames.some(name => name === s.name)).toSorted((a, b) => Primitive_string.compare(a.name, b.name));
-  let finalSortedSchemas = sortedSchemas.concat(remainingSchemas);
+    try {
+      sortedNames = Toposort.sortArray(allNodes, nonCycleEdges).toReversed();
+    } catch (exn$1) {
+      sortedNames = allNodes.toSorted(Primitive_string.compare);
+    }
+  }
+  let finalSortedSchemas = Stdlib_Array.filterMap(sortedNames, name => schemaNameMap[name]);
   let availableSchemaNames = finalSortedSchemas.map(s => s.name);
   let warnings = match[1].slice();
+  let selfRefSchemas = {};
+  finalSortedSchemas.forEach(schema => {
+    let refs = extractReferencedSchemaNames(schema.type_);
+    if (refs.some(name => name === schema.name)) {
+      selfRefSchemas[schema.name] = true;
+      return;
+    }
+  });
   let moduleCodes = finalSortedSchemas.map(schema => {
-    let typeCtx = GenerationContext.make(`ComponentSchemas.` + schema.name, true, availableSchemaNames, undefined, undefined);
-    let schemaCtx = GenerationContext.make(`ComponentSchemas.` + schema.name, true, availableSchemaNames, undefined, undefined);
-    let typeCode = IRToTypeGenerator.generateTypeWithContext(typeCtx, 0, schema.type_);
-    let schemaCode = IRToSuryGenerator.generateSchemaWithContext(schemaCtx, 0, schema.type_);
+    let isSelfRef = Stdlib_Option.getOr(selfRefSchemas[schema.name], false);
+    let selfRefName = isSelfRef ? schema.name : undefined;
+    let typeCtx = GenerationContext.make(`ComponentSchemas.` + schema.name, true, availableSchemaNames, undefined, selfRefName, undefined);
+    let typeCode = IRToTypeGenerator.generateTypeWithContext(typeCtx, 0, undefined, schema.type_);
+    let processed = 0;
+    while (processed < typeCtx.extractedTypes.length) {
+      let idx = processed;
+      let match = typeCtx.extractedTypes[idx];
+      let irType = match.irType;
+      if (match.isUnboxed && typeof irType === "object" && irType.TAG === "Union") {
+        irType._0.forEach(memberType => {
+          IRToTypeGenerator.generateTypeWithContext(typeCtx, 0, true, memberType);
+        });
+      } else {
+        IRToTypeGenerator.generateTypeWithContext(typeCtx, 0, false, irType);
+      }
+      processed = idx + 1 | 0;
+    };
+    let allExtracted = typeCtx.extractedTypes.slice().toReversed();
+    let extractedTypeMap = allExtracted.length !== 0 ? allExtracted : undefined;
+    let schemaCtx = GenerationContext.make(`ComponentSchemas.` + schema.name, true, availableSchemaNames, undefined, selfRefName, undefined);
+    let schemaCode = IRToSuryGenerator.generateSchemaWithContext(schemaCtx, 0, extractedTypeMap, schema.type_);
     warnings.push(...typeCtx.warnings);
     warnings.push(...schemaCtx.warnings);
+    let extractedTypeDefs = allExtracted.map(param => {
+      let irType = param.irType;
+      let typeName = param.typeName;
+      let auxTypeCode;
+      if (param.isUnboxed) {
+        let exit = 0;
+        if (typeof irType !== "object" || irType.TAG !== "Union") {
+          exit = 1;
+        } else {
+          let body = IRToTypeGenerator.generateUnboxedVariantBody(typeCtx, irType._0);
+          auxTypeCode = `@unboxed type ` + typeName + ` = ` + body;
+        }
+        if (exit === 1) {
+          let auxType = IRToTypeGenerator.generateTypeWithContext(typeCtx, 0, undefined, irType);
+          auxTypeCode = `type ` + typeName + ` = ` + auxType;
+        }
+      } else {
+        let auxType$1 = IRToTypeGenerator.generateTypeWithContext(typeCtx, 0, undefined, irType);
+        auxTypeCode = `type ` + typeName + ` = ` + auxType$1;
+      }
+      let auxSchemaCtx = GenerationContext.make(`ComponentSchemas.` + schema.name + `.` + typeName, true, availableSchemaNames, undefined, undefined, undefined);
+      let filteredMap = allExtracted.filter(param => param.typeName !== typeName);
+      let auxExtractedTypeMap = filteredMap.length !== 0 ? filteredMap : undefined;
+      let auxSchema = IRToSuryGenerator.generateSchemaWithContext(auxSchemaCtx, 0, auxExtractedTypeMap, irType);
+      return `  ` + auxTypeCode + `\n  let ` + typeName + `Schema = ` + auxSchema;
+    });
     let docComment = Stdlib_Option.mapOr(schema.description, "", d => CodegenUtils.generateDocString(undefined, d, undefined));
+    let extractedBlock = extractedTypeDefs.length !== 0 ? extractedTypeDefs.join("\n") + "\n" : "";
+    let typeKeyword = isSelfRef ? "type rec t" : "type t";
+    let finalSchemaCode = isSelfRef ? `S.recursive("` + schema.name + `", schema => ` + schemaCode + `)` : schemaCode;
     return docComment + `module ` + JsConvertCase.toPascalCase(schema.name) + ` = {
-  type t = ` + typeCode + `
-  let schema = ` + schemaCode + `
+` + extractedBlock + `  ` + typeKeyword + ` = ` + typeCode + `
+  let schema = ` + finalSchemaCode + `
 }`;
   });
   let fileHeader = CodegenUtils.generateFileHeader("Shared component schemas");
@@ -122,4 +204,4 @@ export {
   extractReferencedSchemaNames,
   generate,
 }
-/* FileSystem Not a pure module */
+/* Toposort Not a pure module */

package/lib/es6/src/generators/EndpointGenerator.mjs

@@ -26,7 +26,7 @@ function generateTypeCodeAndSchemaCode(jsonSchema, typeName, schemaName, moduleP
     name: schemaName,
     description: jsonSchema.description,
     type_: ir
-  }, undefined, undefined, modulePrefix);
+  }, undefined, undefined, modulePrefix, match$1[2]);
   return [
     match$1[0],
     match$2[0]
@@ -45,7 +45,8 @@ function generateEndpointFunction(endpoint, overrideDir, moduleName) {
   let isRequestBodyRequired = Stdlib_Option.getOr(requestBody.required, false);
   let bodyParam = hasRequestBody ? (
       isRequestBodyRequired ? `~body: ` + requestTypeName : `~body: option<` + requestTypeName + `>=?`
-    ) : "~body as _";
+    ) : "";
+  let paramSep = hasRequestBody ? ", " : "";
   let bodyValueConversion = hasRequestBody ? (
       isRequestBodyRequired ? `  let jsonBody = body->S.reverseConvertToJsonOrThrow(` + functionName + `RequestSchema)` : `  let jsonBody = body->Option.map(b => b->S.reverseConvertToJsonOrThrow(` + functionName + `RequestSchema))`
     ) : "";
@@ -86,7 +87,7 @@ function generateEndpointFunction(endpoint, overrideDir, moduleName) {
   let docComment = CodegenUtils.generateDocString(endpoint.summary, description, undefined);
   let code = `
     |` + docComment.trimEnd() + `
-    |let ` + functionName + ` = (` + bodyParam + `, ~fetch: ` + CodegenUtils.fetchTypeSignature + `): promise<` + functionName + `Response> => {
+    |let ` + functionName + ` = (` + bodyParam + paramSep + `~fetch: ` + CodegenUtils.fetchTypeSignature + `): promise<` + functionName + `Response> => {
     |` + bodyValueConversion + `
     |  fetch(
     |    ~url="` + endpoint.path + `",

package/lib/es6/src/generators/IRToSuryGenerator.mjs

@@ -19,7 +19,7 @@ function applyConstraints(base, min, max, toString) {
   }
 }
 
-function generateSchemaWithContext(ctx, depthOpt, irType) {
+function generateSchemaWithContext(ctx, depthOpt, extractedTypeMap, irType) {
   let depth = depthOpt !== undefined ? depthOpt : 0;
   if (depth > 100) {
     GenerationContext.addWarning(ctx, {
@@ -29,7 +29,11 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
     });
     return "S.json";
   }
-  let recurse = nextIrType => generateSchemaWithContext(ctx, depth + 1 | 0, nextIrType);
+  let recurse = nextIrType => generateSchemaWithContext(ctx, depth + 1 | 0, extractedTypeMap, nextIrType);
+  let foundExtracted = extractedTypeMap !== undefined ? extractedTypeMap.find(param => SchemaIR.equals(param.irType, irType)) : undefined;
+  if (foundExtracted !== undefined) {
+    return foundExtracted.typeName + `Schema`;
+  }
   if (typeof irType !== "object") {
     switch (irType) {
       case "Boolean" :
@@ -66,15 +70,46 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
           if (additionalProperties !== undefined) {
             return `S.dict(` + recurse(additionalProperties) + `)`;
           } else {
-            return "S.json";
+            return "S.dict(S.json)";
           }
         }
         let fields = properties.map(param => {
+          let fieldType = param[1];
           let name = param[0];
-          let schemaCode = recurse(param[1]);
+          let schemaCode = recurse(fieldType);
           let camelName = CodegenUtils.escapeKeyword(JsConvertCase.toCamelCase(name));
+          let alreadyNullable = true;
+          if (!schemaCode.startsWith("S.nullableAsOption(")) {
+            let tmp;
+            if (typeof fieldType !== "object") {
+              tmp = false;
+            } else {
+              switch (fieldType.TAG) {
+                case "Union" :
+                  tmp = fieldType._0.some(t => {
+                    if (typeof t !== "object") {
+                      return t === "Null";
+                    }
+                    if (t.TAG !== "Literal") {
+                      return false;
+                    }
+                    let tmp = t._0;
+                    return typeof tmp !== "object";
+                  });
+                  break;
+                case "Option" :
+                  tmp = true;
+                  break;
+                default:
+                  tmp = false;
+              }
+            }
+            alreadyNullable = tmp;
+          }
           if (param[2]) {
             return `    ` + camelName + `: s.field("` + name + `", ` + schemaCode + `),`;
+          } else if (alreadyNullable) {
+            return `    ` + camelName + `: s.fieldOr("` + name + `", ` + schemaCode + `, None),`;
           } else {
             return `    ` + camelName + `: s.fieldOr("` + name + `", S.nullableAsOption(` + schemaCode + `), None),`;
           }
@@ -137,24 +172,150 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
           }
         });
         let arrayItemType = match[2];
-        let result = match[0] && match[1] && effectiveTypes.length === 2 && SchemaIR.equals(Stdlib_Option.getOr(arrayItemType, "Unknown"), Stdlib_Option.getOr(match[3], "Unknown")) ? `S.array(` + recurse(Stdlib_Option.getOr(arrayItemType, "Unknown")) + `)` : (
-            effectiveTypes.every(t => {
-              if (typeof t !== "object") {
-                return false;
+        let result;
+        if (match[0] && match[1] && effectiveTypes.length === 2 && SchemaIR.equals(Stdlib_Option.getOr(arrayItemType, "Unknown"), Stdlib_Option.getOr(match[3], "Unknown"))) {
+          result = `S.array(` + recurse(Stdlib_Option.getOr(arrayItemType, "Unknown")) + `)`;
+        } else if (effectiveTypes.every(t => {
+            if (typeof t !== "object") {
+              return false;
+            }
+            if (t.TAG !== "Literal") {
+              return false;
+            }
+            let tmp = t._0;
+            if (typeof tmp !== "object") {
+              return false;
+            } else {
+              return tmp.TAG === "StringLiteral";
+            }
+          }) && effectiveTypes.length !== 0 && effectiveTypes.length <= 50) {
+          result = `S.union([` + effectiveTypes.map(recurse).join(", ") + `])`;
+        } else if (effectiveTypes.length !== 0) {
+          let runtimeKinds = {};
+          effectiveTypes.forEach(t => {
+            let kind;
+            if (typeof t !== "object") {
+              switch (t) {
+                case "Boolean" :
+                  kind = "boolean";
+                  break;
+                case "Null" :
+                  kind = "null";
+                  break;
+                default:
+                  kind = "unknown";
               }
-              if (t.TAG !== "Literal") {
-                return false;
+            } else {
+              switch (t.TAG) {
+                case "String" :
+                  kind = "string";
+                  break;
+                case "Number" :
+                case "Integer" :
+                  kind = "number";
+                  break;
+                case "Array" :
+                  kind = "array";
+                  break;
+                case "Literal" :
+                  let tmp = t._0;
+                  if (typeof tmp !== "object") {
+                    kind = "null";
+                  } else {
+                    switch (tmp.TAG) {
+                      case "StringLiteral" :
+                        kind = "string";
+                        break;
+                      case "NumberLiteral" :
+                        kind = "number";
+                        break;
+                      case "BooleanLiteral" :
+                        kind = "boolean";
+                        break;
+                    }
+                  }
+                  break;
+                case "Object" :
+                case "Intersection" :
+                case "Reference" :
+                  kind = "object";
+                  break;
+                default:
+                  kind = "unknown";
               }
-              let tmp = t._0;
-              if (typeof tmp !== "object") {
-                return false;
-              } else {
-                return tmp.TAG === "StringLiteral";
+            }
+            let count = Stdlib_Option.getOr(runtimeKinds[kind], 0);
+            runtimeKinds[kind] = count + 1 | 0;
+          });
+          let canUnbox = Object.values(runtimeKinds).every(count => count <= 1);
+          if (canUnbox) {
+            let rawNames = effectiveTypes.map(CodegenUtils.variantConstructorName);
+            let names = CodegenUtils.deduplicateNames(rawNames);
+            let branches = effectiveTypes.map((memberType, i) => {
+              let constructorName = names[i];
+              if (typeof memberType === "object" && memberType.TAG === "Object") {
+                let additionalProperties = memberType.additionalProperties;
+                let properties = memberType.properties;
+                if (properties.length === 0) {
+                  if (additionalProperties !== undefined) {
+                    return `S.dict(` + recurse(additionalProperties) + `)->S.shape(v => ` + constructorName + `(v))`;
+                  } else {
+                    return `S.dict(S.json)->S.shape(v => ` + constructorName + `(v))`;
+                  }
+                }
+                let fields = properties.map(param => {
+                  let fieldType = param[1];
+                  let name = param[0];
+                  let schemaCode = recurse(fieldType);
+                  let camelName = CodegenUtils.escapeKeyword(JsConvertCase.toCamelCase(name));
+                  let alreadyNullable = true;
+                  if (!schemaCode.startsWith("S.nullableAsOption(")) {
+                    let tmp;
+                    if (typeof fieldType !== "object") {
+                      tmp = false;
+                    } else {
+                      switch (fieldType.TAG) {
+                        case "Union" :
+                          tmp = fieldType._0.some(t => {
+                            if (typeof t !== "object") {
+                              return t === "Null";
+                            }
+                            if (t.TAG !== "Literal") {
+                              return false;
+                            }
+                            let tmp = t._0;
+                            return typeof tmp !== "object";
+                          });
+                          break;
+                        case "Option" :
+                          tmp = true;
+                          break;
+                        default:
+                          tmp = false;
+                      }
+                    }
+                    alreadyNullable = tmp;
+                  }
+                  if (param[2]) {
+                    return `      ` + camelName + `: s.field("` + name + `", ` + schemaCode + `),`;
+                  } else if (alreadyNullable) {
+                    return `      ` + camelName + `: s.fieldOr("` + name + `", ` + schemaCode + `, None),`;
+                  } else {
+                    return `      ` + camelName + `: s.fieldOr("` + name + `", S.nullableAsOption(` + schemaCode + `), None),`;
+                  }
+                }).join("\n");
+                return `S.object(s => ` + constructorName + `({\n` + fields + `\n    }))`;
               }
-            }) && effectiveTypes.length !== 0 && effectiveTypes.length <= 50 ? `S.union([` + effectiveTypes.map(recurse).join(", ") + `])` : (
-                effectiveTypes.length !== 0 ? `S.union([` + effectiveTypes.map(recurse).join(", ") + `])` : "S.json"
-              )
-          );
+              let innerSchema = recurse(memberType);
+              return innerSchema + `->S.shape(v => ` + constructorName + `(v))`;
+            });
+            result = `S.union([` + branches.join(", ") + `])`;
+          } else {
+            result = recurse(effectiveTypes[effectiveTypes.length - 1 | 0]);
+          }
+        } else {
+          result = "S.json";
+        }
         if (hasNull) {
           return `S.nullableAsOption(` + result + `)`;
         } else {
@@ -198,11 +359,42 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
         let objectProps = match$1[0];
         if (objectProps.length !== 0 && nonObjectTypes.length === 0) {
           let fields$1 = objectProps.map(param => {
+            let fieldType = param[1];
             let name = param[0];
-            let schemaCode = recurse(param[1]);
+            let schemaCode = recurse(fieldType);
             let camelName = CodegenUtils.escapeKeyword(JsConvertCase.toCamelCase(name));
+            let alreadyNullable = true;
+            if (!schemaCode.startsWith("S.nullableAsOption(")) {
+              let tmp;
+              if (typeof fieldType !== "object") {
+                tmp = false;
+              } else {
+                switch (fieldType.TAG) {
+                  case "Union" :
+                    tmp = fieldType._0.some(t => {
+                      if (typeof t !== "object") {
+                        return t === "Null";
+                      }
+                      if (t.TAG !== "Literal") {
+                        return false;
+                      }
+                      let tmp = t._0;
+                      return typeof tmp !== "object";
+                    });
+                    break;
+                  case "Option" :
+                    tmp = true;
+                    break;
+                  default:
+                    tmp = false;
+                }
+              }
+              alreadyNullable = tmp;
+            }
             if (param[2]) {
               return `    ` + camelName + `: s.field("` + name + `", ` + schemaCode + `),`;
+            } else if (alreadyNullable) {
+              return `    ` + camelName + `: s.fieldOr("` + name + `", ` + schemaCode + `, None),`;
             } else {
               return `    ` + camelName + `: s.fieldOr("` + name + `", S.nullableAsOption(` + schemaCode + `), None),`;
             }
@@ -218,11 +410,42 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
           note: "Mixed object/non-object intersection"
         });
         let fields$2 = objectProps.map(param => {
+          let fieldType = param[1];
           let name = param[0];
-          let schemaCode = recurse(param[1]);
+          let schemaCode = recurse(fieldType);
           let camelName = CodegenUtils.escapeKeyword(JsConvertCase.toCamelCase(name));
+          let alreadyNullable = true;
+          if (!schemaCode.startsWith("S.nullableAsOption(")) {
+            let tmp;
+            if (typeof fieldType !== "object") {
+              tmp = false;
+            } else {
+              switch (fieldType.TAG) {
+                case "Union" :
+                  tmp = fieldType._0.some(t => {
+                    if (typeof t !== "object") {
+                      return t === "Null";
+                    }
+                    if (t.TAG !== "Literal") {
+                      return false;
+                    }
+                    let tmp = t._0;
+                    return typeof tmp !== "object";
+                  });
+                  break;
+                case "Option" :
+                  tmp = true;
+                  break;
+                default:
+                  tmp = false;
+              }
+            }
+            alreadyNullable = tmp;
+          }
           if (param[2]) {
             return `    ` + camelName + `: s.field("` + name + `", ` + schemaCode + `),`;
+          } else if (alreadyNullable) {
+            return `    ` + camelName + `: s.fieldOr("` + name + `", ` + schemaCode + `, None),`;
           } else {
             return `    ` + camelName + `: s.fieldOr("` + name + `", S.nullableAsOption(` + schemaCode + `), None),`;
           }
@@ -230,14 +453,16 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
         return `S.object(s => {\n` + fields$2 + `\n  })`;
       case "Reference" :
         let ref = irType._0;
-        let available = ctx.availableSchemas;
-        let schemaPath;
-        if (available !== undefined) {
-          let name = Stdlib_Option.getOr(ref.split("/")[ref.split("/").length - 1 | 0], "");
-          schemaPath = available.includes(name) ? JsConvertCase.toPascalCase(name) + `.schema` : `ComponentSchemas.` + JsConvertCase.toPascalCase(name) + `.schema`;
-        } else {
-          schemaPath = Stdlib_Option.getOr(ReferenceResolver.refToSchemaPath(ctx.insideComponentSchemas, ctx.modulePrefix, ref), "S.json");
+        let refName = ref.includes("/") ? Stdlib_Option.getOr(ref.split("/")[ref.split("/").length - 1 | 0], "") : ref;
+        let selfName = ctx.selfRefName;
+        let isSelfRef = selfName !== undefined ? refName === selfName : false;
+        if (isSelfRef) {
+          return "schema";
         }
+        let available = ctx.availableSchemas;
+        let schemaPath = available !== undefined ? (
+            available.includes(refName) ? JsConvertCase.toPascalCase(refName) + `.schema` : `ComponentSchemas.` + JsConvertCase.toPascalCase(refName) + `.schema`
+          ) : Stdlib_Option.getOr(ReferenceResolver.refToSchemaPath(ctx.insideComponentSchemas, ctx.modulePrefix, ref), "S.json");
         if (schemaPath === "S.json") {
           GenerationContext.addWarning(ctx, {
             TAG: "FallbackToJson",
@@ -261,21 +486,33 @@ function generateSchema(depthOpt, pathOpt, insideComponentSchemasOpt, availableS
   let path = pathOpt !== undefined ? pathOpt : "";
   let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
   let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
-  let ctx = GenerationContext.make(path, insideComponentSchemas, availableSchemas, modulePrefix, undefined);
+  let ctx = GenerationContext.make(path, insideComponentSchemas, availableSchemas, modulePrefix, undefined, undefined);
   return [
-    generateSchemaWithContext(ctx, depth, irType),
+    generateSchemaWithContext(ctx, depth, undefined, irType),
     ctx.warnings
   ];
 }
 
-function generateNamedSchema(namedSchema, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt) {
+function generateNamedSchema(namedSchema, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt, extractedTypesOpt) {
   let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
   let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
-  let ctx = GenerationContext.make(`schema.` + namedSchema.name, insideComponentSchemas, availableSchemas, modulePrefix, undefined);
+  let extractedTypes = extractedTypesOpt !== undefined ? extractedTypesOpt : [];
+  let ctx = GenerationContext.make(`schema.` + namedSchema.name, insideComponentSchemas, availableSchemas, modulePrefix, undefined, undefined);
   let d = namedSchema.description;
   let doc = d !== undefined ? CodegenUtils.generateDocComment(undefined, d, undefined) : "";
+  let extractedTypeMap = extractedTypes.length !== 0 ? extractedTypes : undefined;
+  let mainSchema = generateSchemaWithContext(ctx, 0, extractedTypeMap, namedSchema.type_);
+  let extractedDefs = extractedTypes.map(param => {
+    let typeName = param.typeName;
+    let auxCtx = GenerationContext.make(`schema.` + typeName, insideComponentSchemas, availableSchemas, modulePrefix, undefined, undefined);
+    let filteredMap = extractedTypes.filter(param => param.typeName !== typeName);
+    let auxExtractedTypeMap = filteredMap.length !== 0 ? filteredMap : undefined;
+    let auxSchema = generateSchemaWithContext(auxCtx, 0, auxExtractedTypeMap, param.irType);
+    return `let ` + typeName + `Schema = ` + auxSchema;
+  });
+  let allDefs = extractedDefs.concat([doc + `let ` + namedSchema.name + `Schema = ` + mainSchema]);
   return [
-    doc + `let ` + namedSchema.name + `Schema = ` + generateSchemaWithContext(ctx, 0, namedSchema.type_),
+    allDefs.join("\n\n"),
     ctx.warnings
   ];
 }
@@ -283,7 +520,7 @@ function generateNamedSchema(namedSchema, insideComponentSchemasOpt, availableSc
 function generateAllSchemas(context) {
   let warnings = [];
   let schemas = Object.values(context.schemas).toSorted((a, b) => Primitive_string.compare(a.name, b.name)).map(s => {
-    let match = generateNamedSchema(s, undefined, undefined, undefined);
+    let match = generateNamedSchema(s, undefined, undefined, undefined, undefined);
     warnings.push(...match[1]);
     return match[0];
   });