@f3liz/rescript-autogen-openapi 0.1.0

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

@@ -0,0 +1,77 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Text from "@std/text";
+import * as CodegenUtils from "../core/CodegenUtils.mjs";
+import * as OpenAPIParser from "../core/OpenAPIParser.mjs";
+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 generateTypeCodeAndSchemaCode(name, schema) {
+  let match = SchemaIRParser.parseJsonSchema(undefined, schema);
+  let ir = match[0];
+  let match$1 = IRToTypeGenerator.generateNamedType({
+    name: name,
+    description: schema.description,
+    type_: ir
+  }, undefined, undefined, undefined);
+  let match$2 = IRToSuryGenerator.generateNamedSchema({
+    name: name + `Schema`,
+    description: schema.description,
+    type_: ir
+  }, undefined, undefined, undefined);
+  return match$1[0] + `\n\n` + match$2[0];
+}
+
+let generateTypeAndSchema = generateTypeCodeAndSchemaCode;
+
+function generateComponentSchemas(components) {
+  return Stdlib_Option.mapOr(Stdlib_Option.flatMap(components, c => c.schemas), "// No component schemas\n", schemas => {
+    let sections = Object.entries(schemas).map(param => generateTypeCodeAndSchemaCode(param[0], param[1])).join("\n\n");
+    return `// Component Schemas\n\n` + sections;
+  });
+}
+
+function generateOperationSchemas(operationId, operation) {
+  let generatePart = (suffix, schemaOpt) => Stdlib_Option.mapOr(schemaOpt, "", schema => generateTypeCodeAndSchemaCode(Text.toPascalCase(operationId) + suffix, schema));
+  let requestBodySchema = Stdlib_Option.flatMap(Stdlib_Option.flatMap(operation.requestBody, body => body.content["application/json"]), mediaType => mediaType.schema);
+  let responses = operation.responses;
+  let successResponseSchema = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.orElse(responses["200"], responses["201"]), response => response.content), content => content["application/json"]), mediaType => mediaType.schema);
+  return [
+    generatePart("Request", requestBodySchema),
+    generatePart("Response", successResponseSchema)
+  ].filter(code => code !== "").join("\n\n");
+}
+
+function generateEndpointModule(path, method, operation) {
+  let operationId = OpenAPIParser.getOperationId(path, method, operation);
+  let docComment = CodegenUtils.generateDocComment(operation.summary, operation.description, undefined);
+  let methodStr = method === "GET" ? "GET" : (
+      method === "PUT" ? "PUT" : (
+          method === "DELETE" ? "DELETE" : (
+              method === "HEAD" ? "HEAD" : (
+                  method === "POST" ? "POST" : (
+                      method === "PATCH" ? "PATCH" : "OPTIONS"
+                    )
+                )
+            )
+        )
+    );
+  let schemasCode = generateOperationSchemas(operationId, operation);
+  return docComment + `module ` + Text.toPascalCase(operationId) + ` = {
+` + CodegenUtils.indent(schemasCode, 2) + `
+
+  let endpoint = "` + path + `"
+  let method = #` + methodStr + `
+}`;
+}
+
+export {
+  generateTypeCodeAndSchemaCode,
+  generateTypeAndSchema,
+  generateComponentSchemas,
+  generateOperationSchemas,
+  generateEndpointModule,
+}
+/* @std/text Not a pure module */

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

@@ -0,0 +1,97 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pipeline from "../core/Pipeline.mjs";
+import * as Text from "@std/text";
+import * as FileSystem from "../core/FileSystem.mjs";
+import * as CodegenUtils from "../core/CodegenUtils.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as OpenAPIParser from "../core/OpenAPIParser.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let clientTypeCode = CodegenUtils.trimMargin(`
+  |type client = {
+  |  baseUrl: string,
+  |  token: option<string>,
+  |  fetch: ` + CodegenUtils.fetchTypeSignature + `,
+  |}
+  |`, undefined);
+
+function generateConnectFunction(title) {
+  return CodegenUtils.trimMargin(`
+    |/** Create a client for ` + title + ` */
+    |let connect = (~baseUrl: string, ~token: option<string>=?, ~fetch: ` + CodegenUtils.fetchTypeSignature + `, ()): client => {
+    |  baseUrl,
+    |  token,
+    |  fetch,
+    |}
+    |`, undefined);
+}
+
+function generateWrapperFunction(endpoint, generatedModuleName) {
+  let operationName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
+  let hasRequestBody = Stdlib_Option.isSome(endpoint.requestBody);
+  let docComment = Stdlib_Option.mapOr(endpoint.summary, "", summary => {
+    let descriptionPart = Stdlib_Option.mapOr(endpoint.description, "", description => {
+      if (description === summary) {
+        return "";
+      } else {
+        return " - " + description;
+      }
+    });
+    return `  /** ` + summary + descriptionPart + ` */\n`;
+  });
+  let signature = hasRequestBody ? `let ` + operationName + ` = (request: ` + generatedModuleName + `.` + operationName + `Request, ~client: client)` : `let ` + operationName + ` = (~client: client)`;
+  let callArguments = hasRequestBody ? "~body=request, " : "";
+  return docComment + `  ` + signature + `: promise<` + generatedModuleName + `.` + operationName + `Response> => 
+    ` + generatedModuleName + `.` + operationName + `(` + callArguments + `~fetch=client.fetch)`;
+}
+
+function generateWrapper(spec, endpoints, extensionEndpointsOpt, outputDir, wrapperModuleNameOpt, generatedModulePrefixOpt, baseModulePrefixOpt) {
+  let extensionEndpoints = extensionEndpointsOpt !== undefined ? extensionEndpointsOpt : [];
+  let wrapperModuleName = wrapperModuleNameOpt !== undefined ? wrapperModuleNameOpt : "Wrapper";
+  let generatedModulePrefix = generatedModulePrefixOpt !== undefined ? generatedModulePrefixOpt : "";
+  let baseModulePrefix = baseModulePrefixOpt !== undefined ? baseModulePrefixOpt : "";
+  let extensionOperationIds = Stdlib_Array.reduce(extensionEndpoints, {}, (acc, endpoint) => {
+    let name = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
+    acc[name] = true;
+    return acc;
+  });
+  let hasExtensions = extensionEndpoints.length !== 0;
+  let allEndpoints = (
+    hasExtensions ? endpoints.filter(endpoint => {
+        let name = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
+        return !(name in extensionOperationIds);
+      }) : endpoints
+  ).concat(extensionEndpoints);
+  let endpointsByTag = OpenAPIParser.groupByTag(allEndpoints);
+  let modulesCode = Object.keys(endpointsByTag).map(tag => {
+    let moduleName = Text.toPascalCase(tag);
+    let wrapperFunctions = Stdlib_Option.getOr(endpointsByTag[tag], []).map(endpoint => {
+      let operationName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
+      let isExtension = hasExtensions && operationName in extensionOperationIds;
+      let prefix = !isExtension && baseModulePrefix !== "" ? baseModulePrefix : generatedModulePrefix;
+      let targetModuleName = prefix !== "" ? prefix + moduleName : moduleName;
+      return generateWrapperFunction(endpoint, targetModuleName);
+    }).join("\n\n");
+    return `module ` + moduleName + ` = {\n` + wrapperFunctions + `\n}`;
+  }).join("\n\n");
+  let fileContent = `// Generated thin wrapper
+
+` + clientTypeCode + `
+
+` + generateConnectFunction(spec.info.title) + `
+
+` + modulesCode;
+  return Pipeline.fromFilesAndWarnings([{
+      path: FileSystem.makePath(outputDir, wrapperModuleName + `.res`),
+      content: fileContent
+    }], []);
+}
+
+export {
+  clientTypeCode,
+  generateConnectFunction,
+  generateWrapperFunction,
+  generateWrapper,
+}
+/* clientTypeCode Not a pure module */

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

@@ -0,0 +1,172 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Text from "@std/text";
+import * as FileSystem from "../core/FileSystem.mjs";
+import * as CodegenUtils from "../core/CodegenUtils.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as OpenAPIParser from "../core/OpenAPIParser.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as SchemaIRParser from "../core/SchemaIRParser.mjs";
+import * as IRToTypeScriptGenerator from "./IRToTypeScriptGenerator.mjs";
+
+function getFirstJsonSchema(contentDict) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Object.keys(contentDict)[0], contentType => contentDict[contentType]), mediaType => mediaType.schema);
+}
+
+function generateTypeScriptType(name, description, schema) {
+  let match = SchemaIRParser.parseJsonSchema(undefined, schema);
+  return IRToTypeScriptGenerator.generateNamedType({
+    name: name,
+    description: description,
+    type_: match[0]
+  });
+}
+
+function generateRequestInterface(endpoint, functionName) {
+  let requestTypeName = Text.toPascalCase(functionName) + `Request`;
+  return Stdlib_Option.flatMap(endpoint.requestBody, body => Stdlib_Option.map(getFirstJsonSchema(body.content), schema => generateTypeScriptType(requestTypeName, body.description, schema)));
+}
+
+function generateResponseInterface(endpoint, functionName) {
+  let responseTypeName = Text.toPascalCase(functionName) + `Response`;
+  let successCodes = [
+    "200",
+    "201",
+    "202",
+    "204"
+  ];
+  let successResponse = Stdlib_Array.filterMap(successCodes, code => endpoint.responses[code])[0];
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(successResponse, response => Stdlib_Option.map(Stdlib_Option.flatMap(response.content, getFirstJsonSchema), schema => generateTypeScriptType(responseTypeName, response.description, schema))), `export type ` + responseTypeName + ` = void;`);
+}
+
+function generateMethodSignature(endpoint, functionName) {
+  let params = Stdlib_Option.isSome(endpoint.requestBody) ? `client: MisskeyClient, request: ` + Text.toPascalCase(functionName) + `Request` : "client: MisskeyClient";
+  let docLines = Stdlib_Option.mapOr(endpoint.summary, [], summary => {
+    let lines = [
+      "  /**",
+      `   * ` + summary
+    ];
+    Stdlib_Option.forEach(endpoint.description, description => {
+      if (description !== summary) {
+        lines.push(`   * ` + description);
+        return;
+      }
+    });
+    lines.push("   */");
+    return lines;
+  });
+  let code = `
+    |` + docLines.join("\n") + `
+    |  ` + functionName + `(` + params + `): Promise<` + Text.toPascalCase(functionName) + `Response>;`;
+  return CodegenUtils.trimMargin(code, undefined);
+}
+
+function generateModuleDts(moduleName, endpoints) {
+  let interfaces = endpoints.map(endpoint => {
+    let functionName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
+    let requestPart = Stdlib_Option.getOr(generateRequestInterface(endpoint, functionName), "");
+    let responsePart = generateResponseInterface(endpoint, functionName);
+    return [
+      requestPart,
+      responsePart
+    ].filter(s => s !== "").join("\n");
+  }).join("\n\n");
+  let methodSignatures = endpoints.map(endpoint => generateMethodSignature(endpoint, CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method))).join("\n");
+  let header = CodegenUtils.trimMargin(`
+    |// TypeScript definitions for ` + moduleName + `
+    |// Generated by @f3liz/rescript-autogen-openapi
+    |// DO NOT EDIT
+    |
+    |import { MisskeyClient } from './index';
+    |import * as ComponentSchemas from './ComponentSchemas';
+    |`, undefined);
+  return CodegenUtils.trimMargin(`
+    |` + header + `
+    |
+    |` + interfaces + `
+    |
+    |export interface ` + moduleName + `Module {
+    |` + methodSignatures + `
+    |}
+    |
+    |export const ` + moduleName + `: ` + moduleName + `Module;
+    |`, undefined);
+}
+
+function generateComponentSchemasDts(schemas) {
+  let content = Object.entries(schemas).map(param => {
+    let schema = param[1];
+    return generateTypeScriptType(param[0], schema.description, schema);
+  }).join("\n\n");
+  return CodegenUtils.trimMargin(`
+    |// TypeScript definitions for ComponentSchemas
+    |// Generated by @f3liz/rescript-autogen-openapi
+    |// DO NOT EDIT
+    |
+    |` + content + `
+    |`, undefined);
+}
+
+function generateIndexDts(moduleNames) {
+  let imports = moduleNames.map(m => `import { ` + m + `Module } from './` + m + `';`).join("\n");
+  let $$exports = moduleNames.map(m => `export const ` + m + `: ` + m + `Module;`).join("\n");
+  return CodegenUtils.trimMargin(`
+    |// TypeScript definitions
+    |// Generated by @f3liz/rescript-autogen-openapi
+    |// DO NOT EDIT
+    |
+    |` + imports + `
+    |
+    |export class MisskeyClient {
+    |  constructor(baseUrl: string, token?: string);
+    |  readonly baseUrl: string;
+    |  readonly token?: string;
+    |}
+    |
+    |` + $$exports + `
+    |`, undefined);
+}
+
+function generate(spec, endpoints, outputDir) {
+  let endpointsByTag = OpenAPIParser.groupByTag(endpoints);
+  let moduleNames = [];
+  let files = Stdlib_Array.filterMap(Object.entries(endpointsByTag), param => {
+    let tagEndpoints = param[1];
+    if (tagEndpoints.length === 0) {
+      return;
+    }
+    let name = Text.toPascalCase(param[0]);
+    moduleNames.push(name);
+    return {
+      path: FileSystem.makePath(outputDir, `types/` + name + `.d.ts`),
+      content: generateModuleDts(name, tagEndpoints)
+    };
+  });
+  Stdlib_Option.forEach(Stdlib_Option.flatMap(spec.components, c => c.schemas), schemas => {
+    files.push({
+      path: FileSystem.makePath(outputDir, "types/ComponentSchemas.d.ts"),
+      content: generateComponentSchemasDts(schemas)
+    });
+  });
+  files.push({
+    path: FileSystem.makePath(outputDir, "types/index.d.ts"),
+    content: generateIndexDts(moduleNames)
+  });
+  return {
+    files: files,
+    warnings: []
+  };
+}
+
+export {
+  getFirstJsonSchema,
+  generateTypeScriptType,
+  generateRequestInterface,
+  generateResponseInterface,
+  generateMethodSignature,
+  generateModuleDts,
+  generateComponentSchemasDts,
+  generateIndexDts,
+  generate,
+}
+/* @std/text Not a pure module */

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

@@ -0,0 +1,145 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pipeline from "../core/Pipeline.mjs";
+import * as Text from "@std/text";
+import * as FileSystem from "../core/FileSystem.mjs";
+import * as CodegenUtils from "../core/CodegenUtils.mjs";
+import * as OpenAPIParser from "../core/OpenAPIParser.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let misskeyClientJsCode = CodegenUtils.trimMargin(`
+  |export class MisskeyClient {
+  |  constructor(baseUrl, token) {
+  |    this.baseUrl = baseUrl;
+  |    this.token = token;
+  |  }
+  |
+  |  async _fetch(url, method, body) {
+  |    const headers = { 'Content-Type': 'application/json' };
+  |    if (this.token) {
+  |      headers['Authorization'] = \`Bearer \${this.token}\`;
+  |    }
+  |    const response = await fetch(this.baseUrl + url, {
+  |      method,
+  |      headers,
+  |      body: body ? JSON.stringify(body) : undefined,
+  |    });
+  |    return response.json();
+  |  }
+  |}`, undefined);
+
+function generateWrapperMjs(endpoints, generatedModulePath) {
+  let endpointsByTag = OpenAPIParser.groupByTag(endpoints);
+  let tags = Object.keys(endpointsByTag);
+  let imports = tags.map(tag => {
+    let moduleName = Text.toPascalCase(tag);
+    return `import * as ` + moduleName + ` from '` + generatedModulePath + `/` + moduleName + `.mjs';`;
+  }).join("\n");
+  let wrappers = tags.map(tag => {
+    let moduleName = Text.toPascalCase(tag);
+    let methods = Stdlib_Option.getOr(endpointsByTag[tag], []).map(endpoint => {
+      let functionName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
+      let hasRequestBody = Stdlib_Option.isSome(endpoint.requestBody);
+      let bodyArg = hasRequestBody ? "body: request, " : "";
+      return `
+            |  async ` + functionName + `(client` + (
+        hasRequestBody ? ", request" : ""
+      ) + `) {
+            |    return ` + moduleName + `.` + functionName + `({
+            |      ` + bodyArg + `fetch: (url, method, body) => client._fetch(url, method, body)
+            |    });
+            |  },`;
+    }).join("\n");
+    return `
+        |export const ` + moduleName + ` = {
+        |` + methods + `
+        |};`;
+  }).join("\n\n");
+  return CodegenUtils.trimMargin(`
+    |// Generated wrapper
+    |` + imports + `
+    |
+    |` + misskeyClientJsCode + `
+    |
+    |` + wrappers + `
+    |`, undefined);
+}
+
+function generateWrapperDts(endpoints) {
+  let endpointsByTag = OpenAPIParser.groupByTag(endpoints);
+  let tags = Object.keys(endpointsByTag);
+  let imports = tags.map(tag => {
+    let moduleName = Text.toPascalCase(tag);
+    let typesToImport = Stdlib_Option.getOr(endpointsByTag[tag], []).flatMap(endpoint => {
+      let pascalName = Text.toPascalCase(CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method));
+      if (Stdlib_Option.isSome(endpoint.requestBody)) {
+        return [
+          `  ` + pascalName + `Request,`,
+          `  ` + pascalName + `Response,`
+        ];
+      } else {
+        return [`  ` + pascalName + `Response,`];
+      }
+    }).join("\n");
+    return `import type {
+` + typesToImport + `
+} from '../types/` + moduleName + `.d.ts';`;
+  }).join("\n");
+  let namespaces = tags.map(tag => {
+    let moduleName = Text.toPascalCase(tag);
+    let functions = Stdlib_Option.getOr(endpointsByTag[tag], []).map(endpoint => {
+      let functionName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
+      let pascalName = Text.toPascalCase(functionName);
+      let docComment = Stdlib_Option.mapOr(endpoint.summary, "", summary => {
+        let descriptionPart = Stdlib_Option.mapOr(endpoint.description, "", description => {
+          if (description === summary) {
+            return "";
+          } else {
+            return " - " + description;
+          }
+        });
+        return `  /** ` + summary + descriptionPart + ` */\n`;
+      });
+      let requestParam = Stdlib_Option.isSome(endpoint.requestBody) ? `, request: ` + pascalName + `Request` : "";
+      return docComment + `  export function ` + functionName + `(client: MisskeyClient` + requestParam + `): Promise<` + pascalName + `Response>;`;
+    }).join("\n");
+    return `
+        |export namespace ` + moduleName + ` {
+        |` + functions + `
+        |}`;
+  }).join("\n\n");
+  return CodegenUtils.trimMargin(`
+    |// Generated TypeScript definitions for wrapper
+    |` + imports + `
+    |
+    |export class MisskeyClient {
+    |  constructor(baseUrl: string, token?: string);
+    |  readonly baseUrl: string;
+    |  readonly token?: string;
+    |}
+    |
+    |` + namespaces + `
+    |`, undefined);
+}
+
+function generate(endpoints, outputDir, generatedModulePathOpt) {
+  let generatedModulePath = generatedModulePathOpt !== undefined ? generatedModulePathOpt : "../generated";
+  return Pipeline.fromFilesAndWarnings([
+    {
+      path: FileSystem.makePath(outputDir, "wrapper/index.mjs"),
+      content: generateWrapperMjs(endpoints, generatedModulePath)
+    },
+    {
+      path: FileSystem.makePath(outputDir, "wrapper/index.d.ts"),
+      content: generateWrapperDts(endpoints)
+    }
+  ], []);
+}
+
+export {
+  misskeyClientJsCode,
+  generateWrapperMjs,
+  generateWrapperDts,
+  generate,
+}
+/* misskeyClientJsCode Not a pure module */

package/lib/es6/src/types/CodegenError.mjs

@@ -0,0 +1,79 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function toString(w) {
+  switch (w.TAG) {
+    case "FallbackToJson" :
+      let context = w.context;
+      return `⚠️  Falling back to JSON.t at '` + context.path + `' (` + context.operation + `): ` + w.reason;
+    case "UnsupportedFeature" :
+      return `⚠️  Unsupported feature '` + w.feature + `' at '` + w.location + `', using fallback: ` + w.fallback;
+    case "DepthLimitReached" :
+      return `⚠️  Depth limit ` + w.depth.toString() + ` reached at '` + w.path + `', using simplified type`;
+    case "MissingSchema" :
+      return `⚠️  Schema reference '` + w.ref + `' not found at '` + w.location + `'`;
+    case "IntersectionNotFullySupported" :
+      return `⚠️  Intersection type at '` + w.location + `' not fully supported: ` + w.note;
+    case "ComplexUnionSimplified" :
+      return `⚠️  Complex union at '` + w.location + `' simplified (types: ` + w.types + `)`;
+  }
+}
+
+function print(warnings) {
+  if (warnings.length !== 0) {
+    console.log("\n⚠️  Warnings:");
+    warnings.forEach(w => {
+      console.log(toString(w));
+    });
+    return;
+  }
+}
+
+let Warning = {
+  toString: toString,
+  print: print
+};
+
+function toString$1(e) {
+  switch (e.TAG) {
+    case "SpecResolutionError" :
+      return `Failed to resolve spec from '` + e.url + `': ` + e.message;
+    case "SchemaParseError" :
+      let context = e.context;
+      return `Failed to parse schema at '` + context.path + `' (` + context.operation + `): ` + e.reason;
+    case "ReferenceError" :
+      let context$1 = e.context;
+      return `Failed to resolve reference '` + e.ref + `' at '` + context$1.path + `' (` + context$1.operation + `)`;
+    case "ValidationError" :
+      return `Validation failed for schema '` + e.schema + `': ` + e.issues.join(", ");
+    case "CircularSchemaError" :
+      return `Circular schema detected for '` + e.ref + `' at depth ` + e.depth.toString() + ` (path: ` + e.path + `)`;
+    case "FileWriteError" :
+      return `Failed to write file '` + e.filePath + `': ` + e.message;
+    case "InvalidConfigError" :
+      return `Invalid configuration for field '` + e.field + `': ` + e.message;
+    case "UnknownError" :
+      let context$2 = e.context;
+      let message = e.message;
+      if (context$2 !== undefined) {
+        return `Unknown error at '` + context$2.path + `' (` + context$2.operation + `): ` + message;
+      } else {
+        return `Unknown error: ` + message;
+      }
+  }
+}
+
+function makeContext(path, operation, schema, param) {
+  return {
+    path: path,
+    operation: operation,
+    schema: schema
+  };
+}
+
+export {
+  Warning,
+  toString$1 as toString,
+  makeContext,
+}
+/* No side effect */

package/lib/es6/src/types/Config.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function make(specPath, outputDir, strategyOpt, modulePerTagOpt, includeTags, excludeTags, generateDiffReportOpt, breakingChangeHandlingOpt, forkSpecs, generateDocOverrides, docOverrideDir, targets, dtsOutputDir, wrapperOutputDir, baseInstanceName, baseModulePrefix, param) {
+  let strategy = strategyOpt !== undefined ? strategyOpt : "SharedBase";
+  let modulePerTag = modulePerTagOpt !== undefined ? modulePerTagOpt : true;
+  let generateDiffReport = generateDiffReportOpt !== undefined ? generateDiffReportOpt : true;
+  let breakingChangeHandling = breakingChangeHandlingOpt !== undefined ? breakingChangeHandlingOpt : "Warn";
+  return {
+    specPath: specPath,
+    forkSpecs: forkSpecs,
+    outputDir: outputDir,
+    strategy: strategy,
+    modulePerTag: modulePerTag,
+    includeTags: includeTags,
+    excludeTags: excludeTags,
+    generateDiffReport: generateDiffReport,
+    breakingChangeHandling: breakingChangeHandling,
+    generateDocOverrides: generateDocOverrides,
+    docOverrideDir: docOverrideDir,
+    targets: targets,
+    dtsOutputDir: dtsOutputDir,
+    wrapperOutputDir: wrapperOutputDir,
+    baseInstanceName: baseInstanceName,
+    baseModulePrefix: baseModulePrefix
+  };
+}
+
+function defaultTargets() {
+  return {
+    rescriptApi: true,
+    rescriptWrapper: false,
+    typescriptDts: false,
+    typescriptWrapper: false
+  };
+}
+
+export {
+  make,
+  defaultTargets,
+}
+/* No side effect */

package/lib/es6/src/types/GenerationContext.mjs

@@ -0,0 +1,24 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function make(path, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt, param) {
+  let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
+  let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
+  return {
+    warnings: [],
+    path: path,
+    insideComponentSchemas: insideComponentSchemas,
+    availableSchemas: availableSchemas,
+    modulePrefix: modulePrefix
+  };
+}
+
+function addWarning(ctx, warning) {
+  ctx.warnings.push(warning);
+}
+
+export {
+  make,
+  addWarning,
+}
+/* No side effect */

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@f3liz/rescript-autogen-openapi",
+  "version": "0.1.0",
+  "description": "Generate ReScript code with Sury schemas from OpenAPI 3.1 specs. Supports multiple forks with diff/merge capabilities.",
+  "keywords": [
+    "rescript",
+    "openapi",
+    "codegen",
+    "sury",
+    "schema",
+    "misskey",
+    "api",
+    "generator"
+  ],
+  "author": "",
+  "license": "MPL-2.0",
+  "files": [
+    "src/**/*.res",
+    "lib/es6/**/*.mjs",
+    "rescript.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "rescript",
+    "clean": "rescript clean",
+    "watch": "rescript build -w",
+    "test": "node --test"
+  },
+  "main": "lib/es6/src/Codegen.mjs",
+  "type": "module",
+  "dependencies": {
+    "@readme/openapi-parser": "^5.5.0",
+    "@std/path": "npm:@jsr/std__path@^1.1.4",
+    "@std/text": "npm:@jsr/std__text@^1.0.17",
+    "sury": "11.0.0-alpha.4"
+  },
+  "devDependencies": {
+    "rescript": "^12.1.0"
+  },
+  "peerDependencies": {
+    "rescript": "^12.0.0"
+  }
+}