@f3liz/rescript-autogen-openapi 0.1.0

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

@@ -0,0 +1,155 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SpecDiffer from "../core/SpecDiffer.mjs";
+import * as CodegenUtils from "../core/CodegenUtils.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+
+function formatEndpointName(endpoint) {
+  let methodPart = endpoint.method.toUpperCase();
+  let operationIdPart = Stdlib_Option.mapOr(endpoint.operationId, "", id => ` (` + id + `)`);
+  return methodPart + ` ` + endpoint.path + operationIdPart;
+}
+
+function formatTags(tags) {
+  return Stdlib_Option.mapOr(tags, "", tagList => {
+    if (tagList.length === 0) {
+      return "";
+    } else {
+      return ` [` + tagList.join(", ") + `]`;
+    }
+  });
+}
+
+function generateMarkdownReport(diff, baseName, forkName) {
+  let generateSection = (title, items, formatter) => {
+    if (items.length === 0) {
+      return "";
+    } else {
+      return `\n### ` + title + `\n\n` + items.map(formatter).join("\n") + `\n`;
+    }
+  };
+  let totalChanges = SpecDiffer.countChanges(diff);
+  let breakingChangesText = SpecDiffer.hasBreakingChanges(diff) ? "⚠️ Yes" : "✓ No";
+  let summaryLines = [
+    `- **Total Changes**: ` + totalChanges.toString(),
+    `- **Added Endpoints**: ` + diff.addedEndpoints.length.toString(),
+    `- **Removed Endpoints**: ` + diff.removedEndpoints.length.toString(),
+    `- **Modified Endpoints**: ` + diff.modifiedEndpoints.length.toString(),
+    `- **Added Schemas**: ` + diff.addedSchemas.length.toString(),
+    `- **Removed Schemas**: ` + diff.removedSchemas.length.toString(),
+    `- **Modified Schemas**: ` + diff.modifiedSchemas.length.toString(),
+    `- **Breaking Changes**: ` + breakingChangesText
+  ].join("\n");
+  let reportParts = [
+    `# API Diff Report: ` + baseName + ` → ` + forkName + `\n\n## Summary\n\n` + summaryLines,
+    generateSection("Added Endpoints", diff.addedEndpoints, endpoint => {
+      let endpointName = formatEndpointName(endpoint);
+      let tags = formatTags(endpoint.tags);
+      let summary = Stdlib_Option.mapOr(endpoint.summary, "", summary => `\n  ` + summary);
+      return `- **` + endpointName + `**` + tags + summary;
+    }),
+    generateSection("Removed Endpoints", diff.removedEndpoints, endpoint => {
+      let endpointName = formatEndpointName(endpoint);
+      let tags = formatTags(endpoint.tags);
+      return `- **` + endpointName + `**` + tags;
+    }),
+    generateSection("Modified Endpoints", diff.modifiedEndpoints, endpointDiff => {
+      let methodPart = endpointDiff.method.toUpperCase();
+      let breakingText = endpointDiff.breakingChange ? " **⚠️ BREAKING**" : "";
+      let changes = [
+        endpointDiff.requestBodyChanged ? "body" : "",
+        endpointDiff.responseChanged ? "response" : ""
+      ].filter(x => x !== "").join(", ");
+      return `- **` + methodPart + ` ` + endpointDiff.path + `**` + breakingText + `: Changed ` + changes;
+    }),
+    generateSection("Added Schemas", diff.addedSchemas, schemaName => `- \`` + schemaName + `\``),
+    generateSection("Removed Schemas", diff.removedSchemas, schemaName => `- \`` + schemaName + `\``),
+    generateSection("Modified Schemas", diff.modifiedSchemas, schemaDiff => {
+      let breakingText = schemaDiff.breakingChange ? " **⚠️ BREAKING**" : "";
+      return `- \`` + schemaDiff.name + `\`` + breakingText;
+    }),
+    `\n---\n*Generated on ` + new Date().toISOString() + `*`
+  ];
+  return reportParts.filter(part => part !== "").join("\n");
+}
+
+function generateCompactSummary(diff) {
+  let totalChanges = SpecDiffer.countChanges(diff);
+  let addedCount = diff.addedEndpoints.length;
+  let removedCount = diff.removedEndpoints.length;
+  let modifiedCount = diff.modifiedEndpoints.length;
+  let breakingText = SpecDiffer.hasBreakingChanges(diff) ? " (BREAKING)" : "";
+  return `Found ` + totalChanges.toString() + ` changes: +` + addedCount.toString() + ` -` + removedCount.toString() + ` ~` + modifiedCount.toString() + ` endpoints` + breakingText;
+}
+
+function generateMergeReport(stats, baseName, forkName) {
+  let sharedEndpoints = stats.sharedEndpointCount.toString();
+  let sharedSchemas = stats.sharedSchemaCount.toString();
+  let extensionEndpoints = stats.forkExtensionCount.toString();
+  let extensionSchemas = stats.forkSchemaCount.toString();
+  return CodegenUtils.trimMargin(`
+    |# Merge Report: ` + baseName + ` + ` + forkName + `
+    |
+    |## Shared Code
+    |
+    |- **Shared Endpoints**: ` + sharedEndpoints + `
+    |- **Shared Schemas**: ` + sharedSchemas + `
+    |
+    |## ` + forkName + ` Extensions
+    |
+    |- **Extension Endpoints**: ` + extensionEndpoints + `
+    |- **Extension Schemas**: ` + extensionSchemas + `
+    |
+    |## Summary
+    |
+    |The shared base contains ` + sharedEndpoints + ` endpoints and ` + sharedSchemas + ` schemas.
+    |
+    |` + forkName + ` adds ` + extensionEndpoints + ` endpoints and ` + extensionSchemas + ` schemas.
+    |
+    |---
+    |*Generated on ` + new Date().toISOString() + `*
+    |`, undefined);
+}
+
+function generateEndpointsByTagReport(endpoints) {
+  let endpointsByTag = {};
+  let untaggedEndpoints = [];
+  endpoints.forEach(endpoint => {
+    let tags = endpoint.tags;
+    if (tags !== undefined && tags.length !== 0) {
+      tags.forEach(tag => {
+        let existing = Stdlib_Option.getOr(endpointsByTag[tag], []);
+        existing.push(endpoint);
+        endpointsByTag[tag] = existing;
+      });
+    } else {
+      untaggedEndpoints.push(endpoint);
+    }
+  });
+  let tagSections = Object.keys(endpointsByTag).toSorted(Primitive_string.compare).map(tag => {
+    let tagEndpoints = Stdlib_Option.getOr(endpointsByTag[tag], []);
+    let count = tagEndpoints.length.toString();
+    let endpointList = tagEndpoints.map(endpoint => `- ` + formatEndpointName(endpoint)).join("\n");
+    return `### ` + tag + ` (` + count + `)\n\n` + endpointList;
+  }).join("\n\n");
+  let untaggedSection;
+  if (untaggedEndpoints.length !== 0) {
+    let count = untaggedEndpoints.length.toString();
+    let endpointList = untaggedEndpoints.map(endpoint => `- ` + formatEndpointName(endpoint)).join("\n");
+    untaggedSection = `\n\n### Untagged (` + count + `)\n\n` + endpointList;
+  } else {
+    untaggedSection = "";
+  }
+  return `## Endpoints by Tag\n\n` + tagSections + untaggedSection;
+}
+
+export {
+  formatEndpointName,
+  formatTags,
+  generateMarkdownReport,
+  generateCompactSummary,
+  generateMergeReport,
+  generateEndpointsByTagReport,
+}
+/* CodegenUtils Not a pure module */

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

@@ -0,0 +1,172 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Text from "@std/text";
+import * as DocOverride from "../core/DocOverride.mjs";
+import * as CodegenUtils from "../core/CodegenUtils.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as SchemaIRParser from "../core/SchemaIRParser.mjs";
+import * as IRToSuryGenerator from "./IRToSuryGenerator.mjs";
+import * as IRToTypeGenerator from "./IRToTypeGenerator.mjs";
+
+function getJsonSchemaFromRequestBody(requestBody) {
+  return Stdlib_Option.flatMap(requestBody, body => Stdlib_Option.flatMap(Object.entries(body.content)[0], param => param[1].schema));
+}
+
+function generateTypeCodeAndSchemaCode(jsonSchema, typeName, schemaName, modulePrefixOpt) {
+  let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
+  let match = SchemaIRParser.parseJsonSchema(undefined, jsonSchema);
+  let ir = match[0];
+  let match$1 = IRToTypeGenerator.generateNamedType({
+    name: typeName,
+    description: jsonSchema.description,
+    type_: ir
+  }, undefined, undefined, modulePrefix);
+  let match$2 = IRToSuryGenerator.generateNamedSchema({
+    name: schemaName,
+    description: jsonSchema.description,
+    type_: ir
+  }, undefined, undefined, modulePrefix);
+  return [
+    match$1[0],
+    match$2[0]
+  ];
+}
+
+function generateEndpointFunction(endpoint, overrideDir, moduleName) {
+  let functionName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
+  let requestTypeName = functionName + `Request`;
+  let hasRequestBody = Stdlib_Option.isSome(endpoint.requestBody);
+  let requestBody = Stdlib_Option.getOr(endpoint.requestBody, {
+    description: undefined,
+    content: {},
+    required: false
+  });
+  let isRequestBodyRequired = Stdlib_Option.getOr(requestBody.required, false);
+  let bodyParam = hasRequestBody ? (
+      isRequestBodyRequired ? `~body: ` + requestTypeName : `~body: option<` + requestTypeName + `>=?`
+    ) : "~body as _";
+  let bodyValueConversion = hasRequestBody ? (
+      isRequestBodyRequired ? `  let jsonBody = body->S.reverseConvertToJsonOrThrow(` + functionName + `RequestSchema)` : `  let jsonBody = body->Option.map(b => b->S.reverseConvertToJsonOrThrow(` + functionName + `RequestSchema))`
+    ) : "";
+  let successResponse = Stdlib_Array.filterMap([
+      "200",
+      "201",
+      "202",
+      "204"
+    ], code => endpoint.responses[code])[0];
+  let responseHandling = Stdlib_Option.mapOr(successResponse, "  response", response => Stdlib_Option.mapOr(response.content, "  let _ = response\n  ()", content => {
+    if (Object.entries(content).length !== 0) {
+      return `  let value = response->S.parseOrThrow(` + functionName + `ResponseSchema)\n  value`;
+    } else {
+      return "  response";
+    }
+  }));
+  let description;
+  if (overrideDir !== undefined && moduleName !== undefined) {
+    let overrideResult = DocOverride.readOverrideWithValidation(overrideDir, moduleName, functionName, DocOverride.generateEndpointHash(endpoint));
+    if (typeof overrideResult !== "object") {
+      description = endpoint.description;
+    } else {
+      switch (overrideResult.TAG) {
+        case "ValidOverride" :
+          description = overrideResult._0;
+          break;
+        case "InvalidHash" :
+          description = overrideResult.override;
+          break;
+        case "FileError" :
+          description = endpoint.description;
+          break;
+      }
+    }
+  } else {
+    description = endpoint.description;
+  }
+  let docComment = CodegenUtils.generateDocString(endpoint.summary, description, undefined);
+  let code = `
+    |` + docComment.trimEnd() + `
+    |let ` + functionName + ` = (` + bodyParam + `, ~fetch: ` + CodegenUtils.fetchTypeSignature + `): promise<` + functionName + `Response> => {
+    |` + bodyValueConversion + `
+    |  fetch(
+    |    ~url="` + endpoint.path + `",
+    |    ~method_="` + endpoint.method.toUpperCase() + `",
+    |    ~body=` + (
+    hasRequestBody ? "Some(jsonBody)" : "None"
+  ) + `,
+    |  )->Promise.then(response => {
+    |` + responseHandling + `
+    |    ->Promise.resolve
+    |  })
+    |}`;
+  return CodegenUtils.trimMargin(code, undefined);
+}
+
+function generateEndpointCode(endpoint, overrideDir, moduleName, modulePrefixOpt) {
+  let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
+  let functionName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
+  let requestJsonSchema = getJsonSchemaFromRequestBody(endpoint.requestBody);
+  let responseJsonSchema = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Array.filterMap([
+      "200",
+      "201",
+      "202",
+      "204"
+    ], code => endpoint.responses[code])[0], resp => resp.content), content => Stdlib_Option.flatMap(Object.entries(content)[0], param => param[1].schema));
+  let requestPart = Stdlib_Option.mapOr(requestJsonSchema, "", schema => {
+    let match = generateTypeCodeAndSchemaCode(schema, functionName + `Request`, functionName + `Request`, modulePrefix);
+    return match[0] + `\n\n` + match[1];
+  });
+  let responsePart = Stdlib_Option.mapOr(responseJsonSchema, `type ` + functionName + `Response = unit`, schema => {
+    let match = generateTypeCodeAndSchemaCode(schema, functionName + `Response`, functionName + `Response`, modulePrefix);
+    return match[0] + `\n\n` + match[1];
+  });
+  return [
+    requestPart,
+    responsePart,
+    generateEndpointFunction(endpoint, overrideDir, moduleName)
+  ].filter(s => s !== "").join("\n\n");
+}
+
+function generateEndpointModule(endpoint, modulePrefixOpt) {
+  let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
+  let functionName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
+  let header = CodegenUtils.generateFileHeader(Stdlib_Option.getOr(endpoint.summary, `API: ` + endpoint.path));
+  return CodegenUtils.trimMargin(`
+    |` + header.trimEnd() + `
+    |
+    |module ` + Text.toPascalCase(functionName) + ` = {
+    |` + CodegenUtils.indent(generateEndpointCode(endpoint, undefined, undefined, modulePrefix), 2) + `
+    |}
+    |`, undefined);
+}
+
+function generateEndpointsModule(moduleName, endpoints, description, overrideDir, modulePrefixOpt) {
+  let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
+  let header = CodegenUtils.generateFileHeader(Stdlib_Option.getOr(description, `API for ` + moduleName));
+  let body = endpoints.map(ep => CodegenUtils.indent(generateEndpointCode(ep, overrideDir, moduleName, modulePrefix), 2)).join("\n\n");
+  return CodegenUtils.trimMargin(`
+    |` + header.trimEnd() + `
+    |
+    |module ` + moduleName + ` = {
+    |` + body + `
+    |}
+    |`, undefined);
+}
+
+function generateEndpointSignature(endpoint) {
+  let functionName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
+  let summaryPrefix = Stdlib_Option.mapOr(endpoint.summary, "", s => `// ` + s + `\n`);
+  let bodyParam = Stdlib_Option.isSome(endpoint.requestBody) ? "~body: 'body, " : "";
+  return summaryPrefix + `let ` + functionName + `: (` + bodyParam + `~fetch: fetchFn) => promise<` + functionName + `Response>`;
+}
+
+export {
+  getJsonSchemaFromRequestBody,
+  generateTypeCodeAndSchemaCode,
+  generateEndpointFunction,
+  generateEndpointCode,
+  generateEndpointModule,
+  generateEndpointsModule,
+  generateEndpointSignature,
+}
+/* @std/text Not a pure module */

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

@@ -0,0 +1,233 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SchemaIR from "../core/SchemaIR.mjs";
+import * as Text from "@std/text";
+import * as CodegenUtils from "../core/CodegenUtils.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as GenerationContext from "../types/GenerationContext.mjs";
+import * as ReferenceResolver from "../core/ReferenceResolver.mjs";
+
+function applyConstraints(base, min, max, toString) {
+  let s1 = min !== undefined ? base + `->S.min(` + toString(Primitive_option.valFromOption(min)) + `)` : base;
+  if (max !== undefined) {
+    return s1 + `->S.max(` + toString(Primitive_option.valFromOption(max)) + `)`;
+  } else {
+    return s1;
+  }
+}
+
+function generateSchemaWithContext(ctx, depthOpt, irType) {
+  let depth = depthOpt !== undefined ? depthOpt : 0;
+  if (depth > 100) {
+    GenerationContext.addWarning(ctx, {
+      TAG: "DepthLimitReached",
+      depth: depth,
+      path: ctx.path
+    });
+    return "S.json";
+  }
+  let recurse = nextIrType => generateSchemaWithContext(ctx, depth + 1 | 0, nextIrType);
+  if (typeof irType !== "object") {
+    switch (irType) {
+      case "Boolean" :
+        return "S.bool";
+      case "Null" :
+        return "S.null";
+      case "Unknown" :
+        return "S.json";
+    }
+  } else {
+    switch (irType.TAG) {
+      case "String" :
+        let c = irType.constraints;
+        let s = applyConstraints("S.string", c.minLength, c.maxLength, v => v.toString());
+        let p = c.pattern;
+        if (p !== undefined) {
+          return s + `->S.pattern(%re("/` + CodegenUtils.escapeString(p) + `/"))`;
+        } else {
+          return s;
+        }
+      case "Number" :
+        let c$1 = irType.constraints;
+        return applyConstraints("S.float", c$1.minimum, c$1.maximum, v => (v | 0).toString());
+      case "Integer" :
+        let c$2 = irType.constraints;
+        return applyConstraints("S.int", c$2.minimum, c$2.maximum, v => (v | 0).toString());
+      case "Array" :
+        let c$3 = irType.constraints;
+        return applyConstraints(`S.array(` + recurse(irType.items) + `)`, c$3.minItems, c$3.maxItems, v => v.toString());
+      case "Object" :
+        let additionalProperties = irType.additionalProperties;
+        let properties = irType.properties;
+        if (properties.length === 0) {
+          if (additionalProperties !== undefined) {
+            return `S.dict(` + recurse(additionalProperties) + `)`;
+          } else {
+            return "S.json";
+          }
+        }
+        let fields = properties.map(param => {
+          let name = param[0];
+          let schemaCode = recurse(param[1]);
+          let camelName = CodegenUtils.escapeKeyword(Text.toCamelCase(name));
+          if (param[2]) {
+            return `    ` + camelName + `: s.field("` + name + `", ` + schemaCode + `),`;
+          } else {
+            return `    ` + camelName + `: s.fieldOr("` + name + `", S.nullableAsOption(` + schemaCode + `), None),`;
+          }
+        }).join("\n");
+        return `S.object(s => {\n` + fields + `\n  })`;
+      case "Literal" :
+        let value = irType._0;
+        if (typeof value !== "object") {
+          return "S.literal(null)";
+        }
+        switch (value.TAG) {
+          case "StringLiteral" :
+            return `S.literal("` + CodegenUtils.escapeString(value._0) + `")`;
+          case "NumberLiteral" :
+            return `S.literal(` + value._0.toString() + `)`;
+          case "BooleanLiteral" :
+            return `S.literal(` + (
+              value._0 ? "true" : "false"
+            ) + `)`;
+        }
+      case "Union" :
+        let types = irType._0;
+        let match = Stdlib_Array.reduce(types, [
+          false,
+          false,
+          undefined,
+          undefined
+        ], (param, t) => {
+          let arrItem = param[2];
+          let hArr = param[0];
+          if (typeof t !== "object" || t.TAG !== "Array") {
+            return [
+              hArr,
+              true,
+              arrItem,
+              t
+            ];
+          } else {
+            return [
+              true,
+              param[1],
+              t.items,
+              param[3]
+            ];
+          }
+        });
+        let arrayItemType = match[2];
+        if (match[0] && match[1] && SchemaIR.equals(Stdlib_Option.getOr(arrayItemType, "Unknown"), Stdlib_Option.getOr(match[3], "Unknown"))) {
+          return `S.array(` + recurse(Stdlib_Option.getOr(arrayItemType, "Unknown")) + `)`;
+        } else if (types.every(t => {
+            if (typeof t !== "object") {
+              return false;
+            }
+            if (t.TAG !== "Literal") {
+              return false;
+            }
+            let tmp = t._0;
+            return typeof tmp !== "object" ? false : tmp.TAG === "StringLiteral";
+          }) && types.length !== 0 && types.length <= 50) {
+          return `S.union([` + types.map(recurse).join(", ") + `])`;
+        } else {
+          GenerationContext.addWarning(ctx, {
+            TAG: "ComplexUnionSimplified",
+            location: ctx.path,
+            types: types.map(SchemaIR.toString).join(" | ")
+          });
+          return "S.json";
+        }
+      case "Intersection" :
+        let types$1 = irType._0;
+        if (types$1.every(t => typeof t !== "object" ? false : t.TAG === "Reference") && types$1.length !== 0) {
+          return recurse(Stdlib_Option.getOr(types$1[types$1.length - 1 | 0], "Unknown"));
+        } else {
+          GenerationContext.addWarning(ctx, {
+            TAG: "IntersectionNotFullySupported",
+            location: ctx.path,
+            note: "Complex intersection"
+          });
+          return "S.json";
+        }
+      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) ? Text.toPascalCase(name) + `.schema` : `ComponentSchemas.` + Text.toPascalCase(name) + `.schema`;
+        } else {
+          schemaPath = Stdlib_Option.getOr(ReferenceResolver.refToSchemaPath(ctx.insideComponentSchemas, ctx.modulePrefix, ref), "S.json");
+        }
+        if (schemaPath === "S.json") {
+          GenerationContext.addWarning(ctx, {
+            TAG: "FallbackToJson",
+            reason: `Unresolved ref: ` + ref,
+            context: {
+              path: ctx.path,
+              operation: "gen ref",
+              schema: undefined
+            }
+          });
+        }
+        return schemaPath;
+      case "Option" :
+        return `S.nullableAsOption(` + recurse(irType._0) + `)`;
+    }
+  }
+}
+
+function generateSchema(depthOpt, pathOpt, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt, irType) {
+  let depth = depthOpt !== undefined ? depthOpt : 0;
+  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);
+  return [
+    generateSchemaWithContext(ctx, depth, irType),
+    ctx.warnings
+  ];
+}
+
+function generateNamedSchema(namedSchema, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt) {
+  let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
+  let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
+  let ctx = GenerationContext.make(`schema.` + namedSchema.name, insideComponentSchemas, availableSchemas, modulePrefix, undefined);
+  let d = namedSchema.description;
+  let doc = d !== undefined ? CodegenUtils.generateDocComment(undefined, d, undefined) : "";
+  return [
+    doc + `let ` + namedSchema.name + `Schema = ` + generateSchemaWithContext(ctx, 0, namedSchema.type_),
+    ctx.warnings
+  ];
+}
+
+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);
+    warnings.push(...match[1]);
+    return match[0];
+  });
+  return [
+    schemas,
+    warnings
+  ];
+}
+
+let addWarning = GenerationContext.addWarning;
+
+export {
+  addWarning,
+  applyConstraints,
+  generateSchemaWithContext,
+  generateSchema,
+  generateNamedSchema,
+  generateAllSchemas,
+}
+/* @std/text Not a pure module */