apigen-ts 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 vladkens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_template.ts

@@ -0,0 +1,65 @@
+// Use uppercase for names in ApiClient to avoid conflict with the generated code
+
+namespace apigen {
+  export type Config = { baseUrl: string; headers: Record<string, string> }
+  export type Req = Omit<RequestInit, "body"> & {
+    search?: Record<string, unknown>
+    body?: unknown
+  }
+}
+
+export class ApiClient {
+  ISO_FORMAT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d*)?(?:[-+]\d{2}:?\d{2}|Z)?$/
+  Config: apigen.Config
+
+  constructor(config?: Partial<apigen.Config>) {
+    this.Config = { baseUrl: "/", headers: {}, ...config }
+  }
+
+  PopulateDates<T>(d: T): T {
+    if (d === null || d === undefined || typeof d !== "object") return d
+
+    const t = d as unknown as Record<string, unknown>
+    for (const [k, v] of Object.entries(t)) {
+      if (typeof v === "string" && this.ISO_FORMAT.test(v)) t[k] = new Date(v)
+      else if (typeof v === "object") this.PopulateDates(v)
+    }
+
+    return d
+  }
+
+  async Fetch<T>(method: string, path: string, config: apigen.Req = {}): Promise<T> {
+    const fallback = globalThis.location?.origin ?? undefined
+    const url = new URL(`${this.Config.baseUrl}/${path}`.replace(/\/+/g, "/"), fallback)
+    for (const [k, v] of Object.entries(config?.search ?? {})) {
+      url.searchParams.append(k, Array.isArray(v) ? v.join(",") : (v as string))
+    }
+
+    const headers = new Headers({ ...this.Config.headers, ...config.headers })
+    const ct = headers.get("content-type") ?? "application/json"
+
+    let body: FormData | string | undefined = undefined
+    if (ct === "multipart/form-data") {
+      headers.delete("content-type") // https://stackoverflow.com/a/61053359/3664464
+      body = new FormData()
+      for (const [k, v] of Object.entries(config.body as Record<string, string>)) {
+        body.append(k, v)
+      }
+    }
+
+    if (ct === "application/json" && typeof config.body !== "string") {
+      headers.set("content-type", "application/json")
+      body = JSON.stringify(config.body)
+    }
+
+    const rep = await fetch(url.toString(), { method, ...config, headers, body })
+    if (!rep.ok) throw rep
+
+    const rs = await rep.text()
+    try {
+      return this.PopulateDates(JSON.parse(rs))
+    } catch (e) {
+      return rs as unknown as T
+    }
+  }
+}

package/dist/cli.js

@@ -0,0 +1,532 @@
+#!/usr/bin/env node
+import { cli } from 'cleye';
+import redocly from '@redocly/openapi-core';
+import { filterNullable, filterEmpty } from 'array-utils-ts';
+import fs from 'fs/promises';
+import { isObject, sortBy, get, lowerFirst, upperFirst, uniqBy, isArray, uniq } from 'lodash-es';
+import { dirname, join } from 'path';
+import * as prettier from 'prettier';
+import { convertObj } from 'swagger2openapi';
+import ts from 'typescript';
+import { fileURLToPath } from 'url';
+
+const f = ts.factory;
+const HttpMethods = ["get", "post", "put", "patch", "delete", "head", "options", "trace"];
+const Keywords = /* @__PURE__ */ new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  "yield",
+  "any",
+  "boolean",
+  "number",
+  "string",
+  "symbol",
+  // "abstract", "as", "async", "await", "constructor", "declare", "from", "get", "is", "module", 
+  // "namespace", "of", "require", "set", "type",
+  "Record",
+  "Partial",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  // ts keywords
+  "Date",
+  "object"
+  // ts type names
+]);
+const initCtx = (doc, cfg) => {
+  return { name: "ApiClient", ...cfg, doc, tag: "", opNames: /* @__PURE__ */ new Set() };
+};
+const normalizeIdentifier = (val, asVar = false) => {
+  let name = val.replace("#/components/schemas/", "").replaceAll("'", "").replace(/[^a-zA-Z0-9]/g, "_");
+  if (name.match(/^\d/))
+    name = `$${name}`;
+  if (asVar && Keywords.has(name))
+    name = `$${name}`;
+  return name;
+};
+const normalizeOpName = (val) => {
+  const articles = /* @__PURE__ */ new Set(["a", "an", "the"]);
+  const tmp = val.replace(/'/, "").replace(/[^a-zA-Z0-9]/g, "_").split("_").filter((x) => x !== "" && !articles.has(x)).map((x) => upperFirst(x));
+  tmp[0] = tmp[0].toUpperCase() === tmp[0] ? tmp[0].toLowerCase() : lowerFirst(tmp[0]);
+  return tmp.join("");
+};
+const getOpName = (ctx, cfg) => {
+  let ns = normalizeOpName(filterEmpty(cfg.tags ?? [])[0] ?? "general");
+  let op = cfg.operationId ?? null;
+  if (!op) {
+    op = cfg.path.replace(/^(\/api)?(\/v?\d\.?\d?)?\/(.+)$/, "$3");
+    op = `${cfg.method}/${op}`.replace(/\/+/, "/");
+  }
+  op = normalizeOpName(op);
+  let nsr = ns.split("").map((x) => `[${x.toUpperCase()}${x.toLowerCase()}]`).join("");
+  if (nsr.endsWith("[Ss]"))
+    nsr += "?";
+  op = op.replace(new RegExp(`^${nsr}([Cc]ontroller|[Ss]ervice)?([A-Z].*)$`), "$2");
+  op = lowerFirst(op);
+  return [ns, op];
+};
+const makeInlineEnum = (s) => {
+  if (!s.enum)
+    return void 0;
+  const values = filterEmpty(s.enum);
+  if (!values.length)
+    return void 0;
+  if (!s.type) {
+    if (values.every((x) => typeof x === "string"))
+      s.type = "string";
+    if (values.every((x) => typeof x === "number"))
+      s.type = "number";
+    if (values.every((x) => typeof x === "boolean"))
+      s.type = "boolean";
+  }
+  if (s.type === "string") {
+    const tokens = uniq(values).map((x) => f.createStringLiteral(x.toString()));
+    return f.createUnionTypeNode(tokens.map((x) => f.createLiteralTypeNode(x)));
+  }
+  if (s.type === "number") {
+    const tokens = uniq(values).map((x) => f.createNumericLiteral(x));
+    return f.createUnionTypeNode(tokens.map((x) => f.createLiteralTypeNode(x)));
+  }
+  if (s.type === "boolean") {
+    const tokens = [];
+    if (values.includes(true))
+      tokens.push(f.createToken(ts.SyntaxKind.TrueKeyword));
+    if (values.includes(false))
+      tokens.push(f.createToken(ts.SyntaxKind.FalseKeyword));
+    return f.createUnionTypeNode(tokens.map((x) => f.createLiteralTypeNode(x)));
+  }
+  console.warn(`enum with unknown type ${s.type}`, s);
+  return void 0;
+};
+const makeType = (ctx, s) => {
+  const mk = makeType.bind(null, ctx);
+  if (s === void 0)
+    return f.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword);
+  if (s === null)
+    return f.createLiteralTypeNode(f.createNull());
+  if ("$ref" in s && s.$ref) {
+    const parts = s.$ref.replace("#/", "").split("/");
+    if (parts.length === 3 && parts[0] === "components" && parts[1] === "schemas") {
+      return f.createTypeReferenceNode(normalizeIdentifier(parts[2], true));
+    }
+    const t = unref(ctx, s);
+    if (!t)
+      throw new Error(`makeTypeRef: ref not found ${JSON.stringify(s)}`);
+    return makeType(ctx, t);
+  }
+  if ("oneOf" in s && s.oneOf)
+    return f.createUnionTypeNode(s.oneOf.map(mk));
+  if ("anyOf" in s && s.anyOf)
+    return f.createUnionTypeNode(s.anyOf.map(mk));
+  if ("allOf" in s && s.allOf)
+    return f.createIntersectionTypeNode(s.allOf.map(mk));
+  if ("type" in s && s.type === "integer")
+    s.type = "number";
+  if ("enum" in s && s.enum && !Array.isArray(s.type)) {
+    const isArray2 = s.type === "array";
+    const t = makeInlineEnum(isArray2 ? { ...s, type: s.items?.type } : s);
+    if (t)
+      return isArray2 ? f.createArrayTypeNode(t) : t;
+  }
+  if ("properties" in s && s.properties) {
+    return f.createTypeLiteralNode(
+      Object.entries(s.properties).map(([k, v]) => {
+        const r = s.required ?? [];
+        const q = r.includes(k) ? void 0 : f.createToken(ts.SyntaxKind.QuestionToken);
+        return f.createPropertySignature(void 0, f.createStringLiteral(k), q, mk(v));
+      })
+    );
+  }
+  if ("type" in s) {
+    if (Array.isArray(s.type)) {
+      const types = [];
+      for (const type of s.type) {
+        if (type === "null")
+          types.push({ type: "null" });
+        else
+          types.push({ ...s, type });
+      }
+      return mk({ oneOf: types });
+    }
+    let t;
+    if (s.type === "object")
+      t = f.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword);
+    else if (s.type === "boolean")
+      t = f.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
+    else if (s.type === "number")
+      t = f.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+    else if (s.type === "string")
+      t = f.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
+    else if (s.type === "array")
+      t = f.createArrayTypeNode(mk(s.items));
+    else if (s.type === "null")
+      t = f.createLiteralTypeNode(f.createNull());
+    else if (isArray(s.type))
+      t = f.createUnionTypeNode(s.type.map((x) => mk({ type: x })));
+    else
+      throw new Error(`makeType: unknown type ${s.type}`);
+    if (s.type === "string") {
+      if (s.format === "binary")
+        t = f.createTypeReferenceNode("File");
+      if (s.format === "date-time")
+        t = f.createTypeReferenceNode("Date");
+    }
+    return s.nullable ? f.createUnionTypeNode([t, f.createLiteralTypeNode(f.createNull())]) : t;
+  }
+  return f.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+};
+const isStringEnum = (s) => {
+  if ("enum" in s && s.enum) {
+    return s.enum.every((x) => typeof x === "string");
+  }
+  return false;
+};
+const makeTypeAlias = (ctx, name, s) => {
+  if (isStringEnum(s)) {
+    const tokens1 = s.enum;
+    const tokens2 = filterEmpty(s.enum);
+    if (tokens1.length !== tokens2.length) {
+      console.warn(`enum ${name} has empty values`, s);
+    }
+    return f.createEnumDeclaration(
+      [f.createToken(ts.SyntaxKind.ExportKeyword)],
+      normalizeIdentifier(name, true),
+      tokens2.map(
+        (x) => f.createEnumMember(upperFirst(normalizeIdentifier(x)), f.createStringLiteral(x))
+      )
+    );
+  }
+  return f.createTypeAliasDeclaration(
+    [f.createToken(ts.SyntaxKind.ExportKeyword)],
+    f.createIdentifier(normalizeIdentifier(name, true)),
+    void 0,
+    makeType(ctx, s)
+  );
+};
+const unref = (ctx, s) => {
+  if (!s)
+    return void 0;
+  if ("$ref" in s && s.$ref) {
+    const parts = s.$ref.replace("#/", "").split("/");
+    const obj = parts.reduce(
+      // openapi encodes "/" in key as "~1"
+      (acc, x) => get(acc, x, get(acc, decodeURIComponent(x).replaceAll("~1", "/"))),
+      ctx.doc
+    );
+    if (obj)
+      return obj;
+    console.warn(`${ctx.tag} ref ${s.$ref} not found`);
+    return void 0;
+  }
+  return s;
+};
+const getReqSchema = (ctx, config) => {
+  const req = unref(ctx, config.requestBody);
+  if (!req)
+    return void 0;
+  const cts = Object.entries(req.content ?? {}).map((x) => [x[0].split(";")[0], x[1].schema]).filter((x) => x[1]);
+  if (cts.length === 0)
+    return void 0;
+  const pretenders = [
+    "application/json",
+    "text/",
+    "multipart/form-data",
+    "application/x-www-form-urlencoded"
+  ];
+  for (const p of pretenders) {
+    const ct = cts.find((x) => x[0].startsWith(p));
+    if (ct)
+      return ct;
+  }
+  cts.map((x) => x[0]);
+  return void 0;
+};
+const getRepSchema = (ctx, config) => {
+  const successCodes = Object.keys(config.responses ?? {}).filter((x) => x.startsWith("2")).filter((x) => get(config, ["responses", x, "content"]));
+  const cts = Object.entries(get(config, ["responses", successCodes[0], "content"], {})).filter((x) => x[1].schema);
+  if (cts.length === 0)
+    return void 0;
+  const ctJson = cts.find((x) => x[0].startsWith("application/json"));
+  if (ctJson)
+    return ctJson[1].schema;
+  const ctText = cts.find((x) => x[0].startsWith("text/"));
+  if (ctText)
+    return { type: "string" };
+  cts.map((x) => x[0]).join(", ");
+  return void 0;
+};
+const prepareUrl = (url, rename) => {
+  for (const [k, v] of Object.entries(rename))
+    url = url.replaceAll(`{${k}}`, "${" + v + "}");
+  const parts = url.split("${");
+  if (parts.length === 1)
+    return f.createStringLiteral(url);
+  return f.createTemplateExpression(
+    f.createTemplateHead(parts[0]),
+    parts.slice(1).map((x, i) => {
+      const [name, ...rest] = x.split("}");
+      const right = rest.join("}");
+      return f.createTemplateSpan(
+        f.createIdentifier(name),
+        // no normalization required
+        i === parts.length - 2 ? f.createTemplateTail(right) : f.createTemplateMiddle(right)
+      );
+    })
+  );
+};
+const prepareOp = (ctx, cfg, opName) => {
+  cfg.parameters = cfg.parameters ?? [];
+  const reqSchema = getReqSchema(ctx, cfg);
+  const repSchema = getRepSchema(ctx, cfg);
+  const allParams = filterNullable(cfg.parameters.map((x) => unref(ctx, x)));
+  const params = uniqBy(allParams.filter((x) => x.in === "path"), "name");
+  if (reqSchema)
+    params.push({ name: "body", schema: reqSchema[1] });
+  const search = allParams.filter((x) => x.in === "query");
+  allParams.filter((x) => x.in === "header");
+  for (const [name, v] of Object.entries({ search })) {
+    if (!v.length)
+      continue;
+    const properties = v.reduce((acc, x) => ({ ...acc, [x.name]: x.schema }), {});
+    params.push({ name, schema: { type: "object", properties } });
+  }
+  const urlReplacements = {};
+  const fnArgs = params.map((x) => {
+    const name = normalizeIdentifier(x.name, true);
+    const type = makeType(ctx, x.schema);
+    urlReplacements[x.name] = name;
+    return f.createParameterDeclaration(void 0, void 0, name, void 0, type);
+  });
+  const cbArgs = filterNullable([
+    search.length ? f.createShorthandPropertyAssignment("search") : void 0,
+    reqSchema && f.createShorthandPropertyAssignment("body"),
+    reqSchema && reqSchema[0] !== "application/json" ? f.createPropertyAssignment(
+      "headers",
+      f.createObjectLiteralExpression([
+        f.createPropertyAssignment(
+          f.createStringLiteral("content-type"),
+          f.createStringLiteral(reqSchema[0])
+        )
+      ])
+    ) : void 0
+  ]);
+  return f.createPropertyAssignment(
+    f.createIdentifier(normalizeIdentifier(opName)),
+    f.createArrowFunction(
+      void 0,
+      void 0,
+      fnArgs,
+      void 0,
+      void 0,
+      f.createBlock([
+        f.createReturnStatement(
+          f.createCallExpression(
+            f.createIdentifier("this.Fetch"),
+            [makeType(ctx, repSchema)],
+            [
+              f.createStringLiteral(cfg.method),
+              // method
+              prepareUrl(cfg.path, urlReplacements),
+              // path
+              f.createObjectLiteralExpression(cbArgs)
+              // { query, body, headers }
+            ]
+          )
+        )
+      ])
+    )
+  );
+};
+const prepareNs = (ctx, name, handlers) => {
+  return f.createPropertyDeclaration(
+    void 0,
+    normalizeIdentifier(name),
+    void 0,
+    void 0,
+    f.createObjectLiteralExpression(handlers)
+  );
+};
+const prepareRoutes = async (ctx) => {
+  const routes = {};
+  for (const [path, pathConfig] of Object.entries(ctx.doc.paths ?? {})) {
+    ctx.tag = `${"[ALL]".toUpperCase().padEnd(6, " ")} ${path}`;
+    if (!isObject(pathConfig))
+      continue;
+    if ("$ref" in pathConfig) {
+      console.warn(`${ctx.tag} $ref should be resolved before (skipping)`);
+      continue;
+    }
+    for (const method of HttpMethods) {
+      ctx.tag = `${method.toUpperCase().padEnd(6, " ")} ${path}`;
+      const config = pathConfig[method];
+      if (!config)
+        continue;
+      if (pathConfig.parameters) {
+        config.parameters = [...config.parameters ?? [], ...pathConfig.parameters];
+      }
+      const [ns, op] = getOpName(ctx, { ...config, method, path });
+      if (!routes[ns])
+        routes[ns] = [];
+      const joined = [ns, op].join(".");
+      if (ctx.opNames.has(joined)) {
+        continue;
+      } else {
+        ctx.opNames.add(joined);
+      }
+      try {
+        routes[ns].push(prepareOp(ctx, { ...config, method, path }, op));
+      } catch (e) {
+        console.error(`${ctx.tag} - ${e}`, config);
+        throw e;
+      }
+    }
+  }
+  return routes;
+};
+const prepareTypes = async (ctx) => {
+  const types = [];
+  const typesConfig = sortBy(Object.entries(ctx.doc.components?.schemas ?? {}), ([k]) => k);
+  for (const [name, config] of typesConfig) {
+    try {
+      types.push(makeTypeAlias(ctx, name, config));
+    } catch (e) {
+      console.error(`${ctx.tag} - ${e}`, name, config);
+      throw e;
+    }
+  }
+  return types;
+};
+const patchTemplate = async (ctx, modules) => {
+  const filepath = join(dirname(fileURLToPath(import.meta.url)), "_template.ts");
+  const file = await fs.readFile(filepath, "utf-8");
+  const root = ts.createSourceFile("tmpl.ts", file, ts.ScriptTarget.Latest);
+  return Array.from(root.statements).map((x) => {
+    if (x.kind === ts.SyntaxKind.ClassDeclaration) {
+      const name = get(x, "name.text");
+      if (name === "ApiClient") {
+        const t = x;
+        return f.updateClassDeclaration(
+          t,
+          t.modifiers,
+          f.createIdentifier(ctx.name),
+          t.typeParameters,
+          t.heritageClauses,
+          addNewLines([...t.members, ...modules])
+        );
+      }
+    }
+    return x;
+  });
+};
+const prepareAst = async (ctx) => {
+  const types = await prepareTypes(ctx);
+  const routes = await prepareRoutes(ctx);
+  const modules = [];
+  for (const [k, v] of Object.entries(routes)) {
+    modules.push(prepareNs(ctx, k, v));
+  }
+  return filterNullable([...await patchTemplate(ctx, modules), ...types]);
+};
+const addNewLines = (nodes) => {
+  const result = [];
+  for (const node of nodes) {
+    result.push(node);
+    result.push(f.createIdentifier("\n"));
+  }
+  return result;
+};
+const loadSchema = async (url) => {
+  const { bundle } = await redocly.bundle({
+    ref: url,
+    config: await redocly.createConfig({}),
+    removeUnusedComponents: false
+  });
+  if (bundle.parsed.swagger) {
+    const { openapi } = await convertObj(bundle.parsed, { patch: true });
+    return openapi;
+  }
+  return bundle.parsed;
+};
+const printCode = async (nodes) => {
+  const code = ts.createPrinter().printFile(
+    f.createSourceFile(
+      addNewLines(nodes),
+      f.createToken(ts.SyntaxKind.EndOfFileToken),
+      ts.NodeFlags.None
+    )
+  ).replaceAll("}, ", "},\n\n");
+  const options = await prettier.resolveConfig(process.cwd());
+  return prettier.format(code, { ...options, parser: "typescript" });
+};
+const apigen = async (source, output, cfg) => {
+  const doc = await loadSchema(source);
+  const ast = await prepareAst(initCtx(doc, cfg));
+  const txt = [
+    `// Auto-generated by https://github.com/vladkens/apigen-ts`,
+    `// Source: ${source}
+`,
+    await printCode(ast)
+  ].join("\n");
+  await fs.mkdir(dirname(output), { recursive: true });
+  await fs.writeFile(output, txt);
+};
+
+const main = async () => {
+  const argv = cli({
+    name: "apigen",
+    // version: "0.0.1",
+    parameters: ["<source>", "<output>"],
+    flags: {
+      name: {
+        type: String,
+        description: "api class name to export",
+        default: "ApiClient"
+      }
+    }
+  });
+  await apigen(argv._.source, argv._.output, { name: argv.flags.name });
+};
+main();

package/package.json

@@ -0,0 +1,55 @@
+{
+  "type": "module",
+  "name": "apigen-ts",
+  "version": "0.0.1",
+  "license": "MIT",
+  "author": "Vlad Pronsky <v.pronsky@gmail.com>",
+  "repository": "vladkens/apigen-ts",
+  "description": "OpenAPI TypeScript client generator",
+  "keywords": [
+    "openapi",
+    "swagger",
+    "typescript",
+    "api",
+    "generator",
+    "codegen"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && pkgroll && cp ./src/_template.ts ./dist && ls -lah dist",
+    "test": "uvu -r tsm test '\\.test\\.ts$'",
+    "test-cov": "c8 --include=src yarn test",
+    "test-watch": "watchexec -c -e ts 'clear && yarn test'",
+    "format": "prettier --write .",
+    "ci": "yarn test-cov && yarn build"
+  },
+  "dependencies": {
+    "@redocly/openapi-core": "^1.4.1",
+    "@types/lodash-es": "^4.17.12",
+    "@types/swagger2openapi": "^7.0.4",
+    "array-utils-ts": "^0.1.2",
+    "cleye": "^1.3.2",
+    "lodash-es": "^4.17.21",
+    "swagger2openapi": "^7.0.8"
+  },
+  "devDependencies": {
+    "@types/node": "^18.18.0",
+    "c8": "^8.0.1",
+    "fetch-mock": "^9.11.0",
+    "pkgroll": "^2.0.1",
+    "prettier": "^3.1.0",
+    "prettier-plugin-organize-imports": "^3.2.4",
+    "tsm": "^2.3.0",
+    "typescript": "^5.3.2",
+    "uvu": "^0.5.6"
+  },
+  "peerDependencies": {
+    "prettier": "^3.0.0",
+    "typescript": "^5.0.0"
+  },
+  "bin": {
+    "apigen-ts": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ]
+}

package/readme.md

@@ -0,0 +1,89 @@
+# OpenAPI TypeScript client generator
+
+<div align="center">
+  <a href="https://npmjs.org/package/apigen-ts">
+    <img src="https://badgen.net/npm/v/apigen-ts" alt="version" />
+  </a>
+  <a href="https://github.com/vladkens/apigen-ts/actions">
+    <img src="https://github.com/vladkens/apigen-ts/workflows/test/badge.svg" alt="test status" />
+  </a>
+  <a href="https://packagephobia.now.sh/result?p=apigen-ts">
+    <img src="https://badgen.net/packagephobia/publish/apigen-ts" alt="size" />
+  </a>
+  <a href="https://npmjs.org/package/apigen-ts">
+    <img src="https://badgen.net/npm/dm/apigen-ts" alt="downloads" />
+  </a>
+  <a href="https://github.com/vladkens/apigen-ts/blob/main/LICENSE">
+    <img src="https://badgen.net/github/license/vladkens/apigen-ts" alt="license" />
+  </a>
+</div>
+
+## Features
+
+- Generates ready to use ApiClient with types (using `fetch`)
+- Single output file, minimal third-party code
+- Load schema from JSON / YAML, locally and remote
+- Ability to customize `fetch` with your custom function
+- Uses `type` instead of `interface`, so no problem with declaration merging
+- Automatic formating with Prettier
+- Parses dates automatically
+
+## Install
+
+```sh
+yarn install -D apigen-ts
+```
+
+## Usage
+
+### Generate
+
+```sh
+# From url
+yarn apigen-ts https://petstore3.swagger.io/api/v3/openapi.json ./api-generated.ts
+
+# From file
+yarn apigen-ts ./openapi.json ./api-generated.ts
+```
+
+### Import
+
+```typescript
+import { ApiClient } from "./api-generated"
+
+const api = new ApiClient({
+  baseUrl: "https://example.com/api",
+  headers: { Authorization: "secret-token" },
+})
+```
+
+### Use
+
+```typescript
+// GET /pet/{petId}
+await api.pet.getPetById(1) // -> Pet
+
+// GET /pet/findByStatus?status=sold
+await api.pet.findPetsByStatus({ status: "sold" }) // -> Pets[]
+
+// PUT /user/{username}
+await api.user.updateUser("username", { firstName: "John" }) // second arg is body with type User
+```
+
+## Advanced
+
+### Login flow
+
+```typescript
+const { token } = await api.auth.login({ usename, password })
+api.Config.headers = { Authorization: token }
+
+await api.protectedRoute.get() // here authenticated
+```
+
+## Useful for development
+
+- https://ts-ast-viewer.com
+- https://jsonschemalint.com
+- https://redocly.github.io/redoc/
+- https://swagger.io/docs/specification/basic-structure/