@f3liz/rescript-autogen-openapi 0.3.1

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

@@ -0,0 +1,172 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 JsConvertCase from "js-convert-case";
+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 = JsConvertCase.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 = JsConvertCase.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: ` + JsConvertCase.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<` + JsConvertCase.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 = JsConvertCase.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,
+}
+/* FileSystem 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 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";
+import * as JsConvertCase from "js-convert-case";
+
+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 = JsConvertCase.toPascalCase(tag);
+    return `import * as ` + moduleName + ` from '` + generatedModulePath + `/` + moduleName + `.mjs';`;
+  }).join("\n");
+  let wrappers = tags.map(tag => {
+    let moduleName = JsConvertCase.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 = JsConvertCase.toPascalCase(tag);
+    let typesToImport = Stdlib_Option.getOr(endpointsByTag[tag], []).flatMap(endpoint => {
+      let pascalName = JsConvertCase.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 = JsConvertCase.toPascalCase(tag);
+    let functions = Stdlib_Option.getOr(endpointsByTag[tag], []).map(endpoint => {
+      let functionName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
+      let pascalName = JsConvertCase.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.d.ts

@@ -0,0 +1,66 @@
+export type context = {
+    readonly path: string;
+    readonly operation: string;
+    readonly schema: (undefined | unknown);
+};
+export type t = {
+    TAG: "SpecResolutionError";
+    readonly url: string;
+    readonly message: string;
+} | {
+    TAG: "SchemaParseError";
+    readonly context: context;
+    readonly reason: string;
+} | {
+    TAG: "ReferenceError";
+    readonly ref: string;
+    readonly context: context;
+} | {
+    TAG: "ValidationError";
+    readonly schema: string;
+    readonly input: unknown;
+    readonly issues: string[];
+} | {
+    TAG: "CircularSchemaError";
+    readonly ref: string;
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "FileWriteError";
+    readonly filePath: string;
+    readonly message: string;
+} | {
+    TAG: "InvalidConfigError";
+    readonly field: string;
+    readonly message: string;
+} | {
+    TAG: "UnknownError";
+    readonly message: string;
+    readonly context: (undefined | context);
+};
+export type Warning_t = {
+    TAG: "FallbackToJson";
+    readonly reason: string;
+    readonly context: context;
+} | {
+    TAG: "UnsupportedFeature";
+    readonly feature: string;
+    readonly fallback: string;
+    readonly location: string;
+} | {
+    TAG: "DepthLimitReached";
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "MissingSchema";
+    readonly ref: string;
+    readonly location: string;
+} | {
+    TAG: "IntersectionNotFullySupported";
+    readonly location: string;
+    readonly note: string;
+} | {
+    TAG: "ComplexUnionSimplified";
+    readonly location: string;
+    readonly types: string;
+};

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.d.ts

@@ -0,0 +1,31 @@
+export type generationStrategy = "Separate" | "SharedBase";
+export type breakingChangeHandling = "Error" | "Warn" | "Ignore";
+export type forkSpecConfig = {
+    readonly name: string;
+    readonly specPath: string;
+};
+export type generationTargets = {
+    readonly rescriptApi: boolean;
+    readonly rescriptWrapper: boolean;
+    readonly typescriptDts: boolean;
+    readonly typescriptWrapper: boolean;
+};
+export type t = {
+    readonly specPath: string;
+    readonly forkSpecs: (undefined | forkSpecConfig[]);
+    readonly outputDir: string;
+    readonly strategy: generationStrategy;
+    readonly modulePerTag: boolean;
+    readonly includeTags: (undefined | string[]);
+    readonly excludeTags: (undefined | string[]);
+    readonly generateDiffReport: boolean;
+    readonly breakingChangeHandling: breakingChangeHandling;
+    readonly generateDocOverrides: (undefined | boolean);
+    readonly docOverrideDir: (undefined | string);
+    readonly targets: (undefined | generationTargets);
+    readonly dtsOutputDir: (undefined | string);
+    readonly wrapperOutputDir: (undefined | string);
+    readonly baseInstanceName: (undefined | string);
+    readonly baseModulePrefix: (undefined | string);
+};
+export declare const make: (specPath: string, outputDir: string, strategy: (undefined | generationStrategy), modulePerTag: (undefined | boolean), includeTags: (undefined | string[]), excludeTags: (undefined | string[]), generateDiffReport: (undefined | boolean), breakingChangeHandling: (undefined | breakingChangeHandling), forkSpecs: (undefined | forkSpecConfig[]), generateDocOverrides: (undefined | boolean), docOverrideDir: (undefined | string), targets: (undefined | generationTargets), dtsOutputDir: (undefined | string), wrapperOutputDir: (undefined | string), baseInstanceName: (undefined | string), baseModulePrefix: (undefined | string), _17: void) => t;

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,47 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SchemaIR from "../core/SchemaIR.mjs";
+
+function make(path, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt, selfRefName, param) {
+  let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
+  let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
+  return {
+    warnings: [],
+    extractedTypes: [],
+    extractCounter: 0,
+    path: path,
+    insideComponentSchemas: insideComponentSchemas,
+    availableSchemas: availableSchemas,
+    modulePrefix: modulePrefix,
+    selfRefName: selfRefName
+  };
+}
+
+function addWarning(ctx, warning) {
+  ctx.warnings.push(warning);
+}
+
+function extractType(ctx, baseName, isUnboxedOpt, irType) {
+  let isUnboxed = isUnboxedOpt !== undefined ? isUnboxedOpt : false;
+  let existing = ctx.extractedTypes.find(param => SchemaIR.equals(param.irType, irType));
+  if (existing !== undefined) {
+    return existing.typeName;
+  }
+  ctx.extractCounter = ctx.extractCounter + 1 | 0;
+  let first = baseName.charAt(0);
+  let lowerBaseName = first === "" ? "extracted" : first.toLowerCase() + baseName.slice(1);
+  let typeName = lowerBaseName + `_` + ctx.extractCounter.toString();
+  ctx.extractedTypes.push({
+    typeName: typeName,
+    irType: irType,
+    isUnboxed: isUnboxed
+  });
+  return typeName;
+}
+
+export {
+  make,
+  addWarning,
+  extractType,
+}
+/* No side effect */

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@f3liz/rescript-autogen-openapi",
+  "version": "0.3.1",
+  "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": "NyanRus",
+  "license": "MPL-2.0",
+  "files": [
+    "src/**/*.res",
+    "lib/es6/src/**/*.mjs",
+    "lib/es6/src/**/*.d.ts",
+    "rescript.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "url": "https://github.com/f3liz-dev/rescript-autogen-openapi"
+  },
+  "scripts": {
+    "build": "rescript && node scripts/generate-dts.mjs",
+    "clean": "rescript clean",
+    "watch": "rescript build -w",
+    "test": "node --test",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "main": "lib/es6/src/Codegen.mjs",
+  "types": "lib/es6/src/Codegen.d.ts",
+  "type": "module",
+  "dependencies": {
+    "@readme/openapi-parser": "^5.5.0",
+    "js-convert-case": "^4.2.0",
+    "pathe": "^2.0.3",
+    "toposort": "^2.0.2"
+  },
+  "devDependencies": {
+    "rescript": "^12.1.0",
+    "sury": "11.0.0-alpha.4",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "rescript": "^12.0.0",
+    "sury": ">=11.0.0-alpha.4"
+  }
+}

package/rescript.json

@@ -0,0 +1,26 @@
+{
+  "name": "@f3liz/rescript-autogen-openapi",
+  "sources": [
+    {
+      "dir": "src",
+      "subdirs": true
+    }
+  ],
+  "package-specs": [
+    {
+      "module": "esmodule",
+      "in-source": false
+    }
+  ],
+  "suffix": ".mjs",
+  "gentypeconfig": {
+    "language": "typescript",
+    "module": "es6",
+    "importPath": "relative",
+    "generatedFileExtension": ".gen.ts"
+  },
+  "dependencies": [],
+  "warnings": {
+    "number": "-44-102"
+  }
+}