@sebspark/openapi-typegen 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright [2023] [SEB]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,20 @@
+# `@sebspark/openapi-typegen`
+
+Generates types and a routerdefinition from OpenAPI specs
+
+## Usage
+
+This is an example assuming that you have one schema, `marketdata.json`. The name
+of this file will be used to generate Server and Client names.
+
+This example can be found in [@sebspark/openapi-e2e](../packages/openapi-e2e)
+
+```zsh
+yarn openapi-typegen -i ./src/schemas/marketdata.json -o ./src/schemas/
+```
+
+The schema will export all types defined in the OpenAPI spec as well as:
+
+`MarketdataAPIServer` - a server definition meant to be used with [@sebspark/openapi-express](./packages/openapi-express)
+
+`MarketDataAPIClient` - a client definition meant to be used with [@sebspark/openapi-client](./packages/openapi-client)

package/cli.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import { generate } from '@sebspark/openapi-typegen'
+import yargs from 'yargs'
+import chalk from 'chalk'
+import boxen from 'boxen'
+
+const usage = chalk.magenta(
+  '\nUsage: @sebspark/typegen --input ./schemas --output ./dist \n' +
+    boxen(
+      chalk.green('\n' + 'Generates Typescript from OpenAPI schemas' + '\n'),
+      {
+        padding: 1,
+        borderColor: 'green',
+        dimBorder: true,
+      },
+    ) +
+    '\n',
+)
+
+const argv = yargs(process.argv.slice(2))
+  .usage(usage)
+  .options({
+    input: { alias: 'i', type: 'string', demandOption: true },
+    output: { alias: 'o', type: 'string', demandOption: false },
+  })
+  .help()
+  .parseSync()
+
+generate({ input: argv.input, output: argv.output })

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+type Options = {
+    input: string;
+    output?: string;
+};
+declare const generate: ({ input, output, }: Options) => Promise<string | string[] | void>;
+
+export { Options, generate };

package/dist/index.js

@@ -0,0 +1,568 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  generate: () => generate
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/generator.ts
+var fastGlob = __toESM(require("fast-glob"));
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_yaml = require("yaml");
+
+// src/shared/format.ts
+var prettier = require("prettier");
+var header = `/**
+ * This file was auto-generated.
+ * Do not make direct changes to the file.
+ */
+
+import {
+  APIServerDefinition,
+  BaseClient,
+  GenericRouteHandler,
+} from '@sebspark/openapi-core'
+ 
+/* tslint:disable */
+/* eslint-disable */`;
+var formatFile = async (rows) => {
+  const withHeader = [header, ...rows];
+  const code = withHeader.join("\n\n");
+  const formatted = await prettier.format(code, {
+    parser: "typescript",
+    singleQuote: true,
+    semi: false
+  });
+  return formatted;
+};
+
+// src/shared/imports/format.ts
+var formatImports = (imports) => {
+  const rows = [];
+  const importsMap = imports.reduce(
+    (map, it) => {
+      if (!map[it.file])
+        map[it.file] = /* @__PURE__ */ new Set();
+      map[it.file].add(it.type);
+      return map;
+    },
+    {}
+  );
+  Object.entries(importsMap).forEach(([file, types]) => {
+    rows.push(`import { ${Array.from(types).join(", ")} } from './${file}'`);
+  });
+  return rows;
+};
+
+// src/shared/schema/format.ts
+var formatDocs = (description) => {
+  if (description) {
+    return `
+/**
+* ${description}
+ */
+`;
+  } else {
+    return "";
+  }
+};
+var formatTypeName = (name) => {
+  return name.replace(/[^a-zA-Z0-9_$]/g, "_");
+};
+var formatParsedType = (parsedType) => {
+  return `${formatDocs(parsedType.description)}export type ${parsedType.name} = ${parsedType.type}`;
+};
+var formatParsedTypes = (types) => {
+  const rows = [];
+  Object.values(types).forEach((values) => rows.push(formatParsedType(values)));
+  return rows;
+};
+var formatProperties = (properties) => {
+  const allProps = properties.map(({ name, required, value, description }) => {
+    return `${formatDocs(description)}'${name}'${required ? "" : "?"}: ${value}`;
+  }).join(`; `);
+  return `{${allProps}}`;
+};
+
+// src/shared/schema/parser.ts
+var parseRefString = (refString, addImport) => {
+  const [file, rest] = refString.split("#");
+  const typeName = formatTypeName(rest.substring(rest.lastIndexOf("/") + 1));
+  if (file && file.length > 0) {
+    const [fileName] = file.split(".");
+    addImport({ file: fileName, type: typeName });
+  }
+  return typeName;
+};
+var parseTypes = (schemas) => {
+  const imports = [];
+  const types = Object.entries(schemas).map(([name, schema]) => {
+    const schemaObj = schema;
+    return {
+      name: formatTypeName(name),
+      type: generateFromSchemaObject(schemaObj, (importData) => {
+        imports.push(importData);
+      }),
+      description: schemaObj.description
+    };
+  });
+  return [types, imports];
+};
+var guessType = (schema) => {
+  if (schema.type) {
+    return schema.type;
+  } else if (schema.enum) {
+    return "string";
+  } else if (schema.properties) {
+    return "object";
+  } else {
+    return void 0;
+  }
+};
+var generateFromSchemaObject = (schema, addImport) => {
+  if ("$ref" in schema) {
+    const { $ref } = schema;
+    return parseRefString($ref, addImport);
+  }
+  const type = guessType(schema);
+  let schemaString = "";
+  if (type) {
+    if (type === "object") {
+      schemaString = generateObject(schema, addImport);
+    } else if (type === "array") {
+      const arrayType = generateFromSchemaObject(schema.items, addImport);
+      if (arrayType && arrayType.length) {
+        schemaString = `(${arrayType})[]`;
+      } else {
+        schemaString = "[]";
+      }
+    } else {
+      switch (type) {
+        case "integer":
+          schemaString = "number";
+          break;
+        case "string": {
+          if (schema.format === "date-time" || schema.format === "date") {
+            schemaString = "Date";
+          } else if (schema.enum) {
+            schemaString = schema.enum.map((it) => `'${it}'`).join(" | ");
+          } else {
+            schemaString = "string";
+          }
+          break;
+        }
+        default:
+          schemaString = type;
+      }
+    }
+  }
+  if (schema.allOf) {
+    const allOfString = schema.allOf.map((it) => generateFromSchemaObject(it, addImport)).join(" & ");
+    if (allOfString.length > 0) {
+      schemaString = schemaString + " & " + allOfString;
+    }
+  }
+  if (schema.anyOf) {
+    const anyOfString = schema.anyOf.map((it) => generateFromSchemaObject(it, addImport)).map((it) => `Partial<${it}>`).join(" & ");
+    if (anyOfString.length > 0) {
+      schemaString = schemaString + " & " + anyOfString;
+    }
+  }
+  if (schema.oneOf) {
+    const oneOfString = schema.oneOf.map((it) => generateFromSchemaObject(it, addImport)).join(" | ");
+    if (oneOfString.length > 0) {
+      schemaString = schemaString + " & (" + oneOfString + ")";
+    }
+  }
+  if (!schemaString || !schemaString.length) {
+    schemaString = "string";
+  }
+  return schemaString;
+};
+var generateObject = (schema, addImport) => {
+  const requiredFields = schema.required ?? [];
+  const properties = Object.entries(
+    schema.properties ?? []
+  ).map(([name, schema2]) => ({
+    [name]: {
+      name,
+      value: generateFromSchemaObject(schema2, addImport),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      description: schema2["description"],
+      required: requiredFields.includes(name)
+    }
+  })).reduce((acc, current) => {
+    for (const key in current) {
+      acc[key] = current[key];
+    }
+    return acc;
+  }, {});
+  return formatProperties(Object.values(properties));
+};
+
+// src/shared/schema/generator.ts
+var generateSchemas = (components) => {
+  const [types, imports] = parseTypes(components.components.schemas);
+  return formatFile([...formatImports(imports), ...formatParsedTypes(types)]);
+};
+
+// src/format.ts
+var formatTitle = (title) => {
+  return title.replace(/ /g, "").replace(/[^a-zA-Z0-9]/g, "_");
+};
+
+// src/openapi/format.ts
+var import_change_case = require("change-case");
+var formatRoutes = (title, routes) => {
+  const formattedTitle = formatTitle(title);
+  const routeDefinitions = generateRouteDefinitions(routes);
+  const server = generateServerAPI(formattedTitle, routeDefinitions);
+  const client = generateClientAPI(formattedTitle, routeDefinitions);
+  return server.concat(client);
+};
+var generateServerAPI = (name, routes) => {
+  const map = generateServerType(routes);
+  const rows = [];
+  rows.push(
+    `export type ${name}Server = APIServerDefinition & {
+${Object.entries(map).map(
+      ([url, methods]) => `  '${url}': {
+${Object.entries(methods).map(
+        ([method, definition]) => `    '${method}': {
+    handler: (${serializeArgs(definition.args)}) => Promise<[${definition.response.code}, ${definition.response.type}]>
+    pre?: GenericRouteHandler | GenericRouteHandler[]
+  }`
+      ).join("\n")}
+  },`
+    ).join("\n")}
+}
+`
+  );
+  return rows;
+};
+var generateClientAPI = (name, routes) => {
+  const code = [];
+  const clientHandlers = [];
+  const verbMap = generateClientType(routes);
+  Object.entries(verbMap).forEach(([verb, definitions]) => {
+    const type = `${name}Client${(0, import_change_case.pascalCase)(verb)}`;
+    clientHandlers.push(`${verb}: ${type}`);
+    code.push(`type ${type} = {`);
+    definitions.forEach((def) => {
+      const args = serializeArgs(def.args);
+      const argsString = args ? `, ${args}` : "";
+      code.push(
+        `(url: '${def.url}'${argsString}): Promise<${def.response.type}>`
+      );
+    });
+    code.push("}");
+  });
+  code.push(
+    `export type ${name}Client = Pick<BaseClient, ${Object.keys(verbMap).map((v) => `'${v}'`).join(" | ")}> & {`
+  );
+  code.push(clientHandlers.join("\n"));
+  code.push("}");
+  return code;
+};
+var generateRouteDefinitions = (routes) => routes.map((route) => ({
+  method: route.method.toLowerCase(),
+  response: route.response,
+  url: route.url,
+  args: parseArgs(route)
+}));
+var generateClientType = (routes) => routes.reduce((router, routeDefinition) => {
+  if (!router[routeDefinition.method])
+    router[routeDefinition.method] = [];
+  router[routeDefinition.method].push(routeDefinition);
+  return router;
+}, {});
+var generateServerType = (routes) => routes.reduce((router, routeDefinition) => {
+  const route = router[routeDefinition.url] || {};
+  route[routeDefinition.method] = routeDefinition;
+  router[routeDefinition.url] = route;
+  return router;
+}, {});
+var parseArgs = (route) => {
+  const args = {};
+  if (route.requestParams !== "never")
+    args.params = route.requestParams;
+  if (route.requestQuery !== "never")
+    args.query = route.requestQuery;
+  if (route.requestHeaders !== "never")
+    args.headers = route.requestHeaders;
+  if (route.requestBody !== "never")
+    args.body = route.requestBody;
+  if (args.headers || args.params || args.query || args.body)
+    return args;
+};
+var serializeArgs = (args) => {
+  if (!args)
+    return "";
+  const argsString = Object.entries(args).map(([key, value]) => `${key}: ${value}`).join(",");
+  return `args: {${argsString}}`;
+};
+
+// src/openapi/parser.ts
+var parseReferencableObjects = (name, record) => {
+  const objects = {};
+  if (record) {
+    const allParameters = Object.entries(record);
+    const referenceParameters = allParameters.filter((it) => "$ref" in it[1]).map((it) => [it[0], it[1]]);
+    const normalParameters = allParameters.filter((it) => !("$ref" in it[1])).map((it) => [it[0], it[1]]);
+    normalParameters.forEach((it) => {
+      objects[`#/components/${name}/${it[0]}`] = it[1];
+    });
+    referenceParameters.forEach((it) => {
+      objects[`#/components/${name}/${it[0]}`] = objects[it[1].$ref];
+    });
+  }
+  return objects;
+};
+
+// src/openapi/paths.ts
+var pathGenerator = (globalParameters) => {
+  const expressifyPath = (path) => path.replace(/{/g, ":").replace(/}/g, "");
+  const parseResponse = (response, addImports) => {
+    var _a, _b;
+    const schema = (_b = (_a = response.content) == null ? void 0 : _a["application/json"]) == null ? void 0 : _b.schema;
+    if (!schema)
+      return "";
+    return generateFromSchemaObject(schema, addImports);
+  };
+  const getType = (param, addImport) => {
+    if (param.type)
+      param.type;
+    if (param.schema) {
+      if ("type" in param.schema)
+        return generateFromSchemaObject(param.schema, addImport);
+    }
+    return "any";
+  };
+  const propName = (name) => {
+    if (name.indexOf("-") === -1)
+      return name;
+    return `'${name}'`;
+  };
+  const generateProps = (params, filter, addImport) => {
+    const props = params.map((it) => {
+      if ("$ref" in it) {
+        return globalParameters[it.$ref];
+      } else {
+        return it;
+      }
+    }).filter((p) => p.in === filter).map(
+      (p) => `${propName(p.name)}${p.required ? "" : "?"}: ${getType(
+        p,
+        addImport
+      )}`
+    );
+    if (props.length)
+      return `{${props.join(", ")}}`;
+    return "never";
+  };
+  const generateBody = (body, addImport) => {
+    var _a, _b;
+    if ((_a = body == null ? void 0 : body.content) == null ? void 0 : _a["application/json"]) {
+      const content = (_b = body.content["application/json"]) == null ? void 0 : _b.schema;
+      return generateFromSchemaObject(content, addImport);
+    }
+    return "never";
+  };
+  const generateResponses = (responses, addImport, errors = false) => {
+    const responseTypes = Object.entries(responses).map(([strCode, response]) => {
+      const code = parseInt(strCode, 10);
+      if (code >= 400 !== errors)
+        return;
+      if ("$ref" in response) {
+        return {
+          code,
+          type: parseRefString(response.$ref, addImport)
+        };
+      }
+      return {
+        code,
+        type: parseResponse(response, addImport) || "void"
+      };
+    }).filter((r) => r);
+    return responseTypes;
+  };
+  const generateRoutes = (path, item, addImport) => {
+    const verbs = ["get", "post", "put", "patch", "delete"];
+    const routes = verbs.map((verb) => {
+      const operation = item[verb];
+      if (!operation)
+        return void 0;
+      const route = {
+        url: expressifyPath(path),
+        method: verb,
+        requestBody: generateBody(
+          operation.requestBody,
+          addImport
+        ),
+        requestParams: generateProps(
+          operation.parameters || [],
+          "path",
+          addImport
+        ),
+        requestQuery: generateProps(
+          operation.parameters || [],
+          "query",
+          addImport
+        ),
+        requestHeaders: generateProps(
+          operation.parameters || [],
+          "header",
+          addImport
+        ),
+        response: generateResponses(operation.responses, addImport)[0],
+        errorResponses: generateResponses(
+          operation.responses,
+          addImport,
+          true
+        )
+      };
+      return route;
+    }).filter((r) => r);
+    return routes;
+  };
+  const generatePaths = (paths) => {
+    const imports = [];
+    const routes = Object.entries(paths).flatMap(
+      ([path, item]) => generateRoutes(path, item, (imp) => imports.push(imp))
+    );
+    return [routes, imports];
+  };
+  return {
+    generate: generatePaths
+  };
+};
+
+// src/openapi/generator.ts
+var generateData = (schema) => {
+  var _a, _b, _c;
+  const [types, importsFromTypes] = ((_a = schema.components) == null ? void 0 : _a.schemas) ? parseTypes(schema.components.schemas) : [[], []];
+  const parameters = parseReferencableObjects(
+    "parameters",
+    ((_b = schema.components) == null ? void 0 : _b.parameters) || {}
+  );
+  const [paths, importsFromPaths] = pathGenerator(parameters).generate(
+    schema.paths || {}
+  );
+  return {
+    types,
+    paths,
+    imports: importsFromPaths.concat(importsFromTypes),
+    title: ((_c = schema.info) == null ? void 0 : _c.title) ?? ""
+  };
+};
+var generateFormattedString = async ({
+  title,
+  imports,
+  paths,
+  types
+}) => {
+  const formattedImports = formatImports(imports);
+  const formattedTypes = formatParsedTypes(types);
+  const formattedRoutes = formatRoutes(title, paths);
+  const formatted = await formatFile([
+    ...formattedImports,
+    ...formattedTypes,
+    ...formattedRoutes
+  ]);
+  return formatted;
+};
+var generateOpenApi = async (schema) => {
+  const data = generateData(schema);
+  const formatted = await generateFormattedString(data);
+  return formatted;
+};
+
+// src/generator.ts
+var getSchemas = async (input) => {
+  const schemas = {
+    openApi: {},
+    // asyncApi: {},
+    sharedTypes: {}
+  };
+  const files = fastGlob.sync(input, { globstar: true, dot: true });
+  for (const file of files) {
+    const { name } = (0, import_path.parse)(file);
+    const content = await (0, import_promises.readFile)(file, "utf-8");
+    const parsed = file.endsWith(".yaml") || file.endsWith(".yml") ? (0, import_yaml.parse)(content) : JSON.parse(content);
+    if (parsed["asyncapi"]) {
+    } else if (parsed["openapi"]) {
+      schemas.openApi[name] = parsed;
+    } else if (parsed["components"]) {
+      schemas.sharedTypes[name] = parsed;
+    }
+  }
+  return schemas;
+};
+var generate = async ({
+  input,
+  output
+}) => {
+  if (!input)
+    throw new Error("You need to supply at least one schema");
+  const schemas = await getSchemas(input);
+  const generatedOpenApi = await Promise.all(
+    Object.entries(schemas.openApi).map(async ([name, schema]) => ({
+      name,
+      schema: await generateOpenApi(schema)
+    }))
+  );
+  const generatedSharedTypes = await Promise.all(
+    Object.entries(schemas.sharedTypes).map(async ([name, schema]) => ({
+      name,
+      schema: await generateSchemas(schema)
+    }))
+  );
+  if (!output)
+    return generatedOpenApi.concat(generatedSharedTypes).map(
+      ({ name, schema }) => `/**
+ * ${name}
+ */
+${schema}
+`
+    ).join("\n");
+  await (0, import_promises.mkdir)(output, { recursive: true });
+  for (const { name, schema } of generatedOpenApi.concat(generatedSharedTypes)) {
+    const path = (0, import_path.join)(output, `${name}.ts`);
+    await (0, import_promises.writeFile)(path, schema, "utf-8");
+  }
+  return;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generate
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@sebspark/openapi-typegen",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "openapi-typegen": "./cli.mjs"
+  },
+  "files": [
+    "dist",
+    "cli.mjs"
+  ],
+  "scripts": {
+    "build": "tsup-node src/index.ts src/cli.ts --format cjs --dts",
+    "dev": "tsc --watch --noEmit",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "test": "vitest --passWithNoTests --coverage",
+    "typecheck": "vitest typecheck --passWithNoTests"
+  },
+  "devDependencies": {
+    "@types/yargs": "17.0.30",
+    "tsconfig": "*"
+  },
+  "dependencies": {
+    "@sebspark/openapi-core": "*",
+    "boxen": "<6",
+    "chalk": "<5",
+    "change-case": "4.1.2",
+    "prettier": "3.0.3",
+    "yargs": "17.7.2",
+    "yarn": "1.22.19"
+  }
+}