@technicity/openapi-sdk-generator 2.0.0

package/src/generate.ts

@@ -0,0 +1,954 @@
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+import * as child_process from "child_process";
+import * as fetch from "node-fetch";
+import { compile } from "json-schema-to-typescript";
+const SwaggerParser = require("@apidevtools/swagger-parser");
+const Ajv = require("ajv");
+const toJsonSchema = require("@openapi-contrib/openapi-schema-to-json-schema");
+const fse = require("fs-extra");
+const traverse = require("json-schema-traverse");
+const { json2ts } = require("json-ts");
+const prettier = require("prettier");
+const prependFile = require("prepend-file");
+
+export const schema = {
+  type: "object",
+  properties: {
+    def: {
+      type: "string",
+      description: "Path or URL to OpenAPI definition",
+    },
+    outdir: {
+      type: "string",
+      description: "Directory in which to generate files",
+    },
+    preProcessDef: {
+      type: "string",
+      description:
+        "String for JS function to run on OpenAPI def before prior to validation and de-referencing",
+    },
+    cacheType: {
+      type: "string",
+      enum: ["memory", "none"],
+      default: "memory",
+      description: "'memory' | 'none'",
+    },
+    throwOnNotOkayRes: {
+      type: "boolean",
+      default: false,
+      description:
+        "Whether a SDK method should throw when the response status code is not okay",
+    },
+    packageName: {
+      type: "string",
+    },
+    packageAuthor: {
+      type: "string",
+    },
+    packageDescription: {
+      type: "string",
+    },
+    module: {
+      type: "string",
+      enum: ["CommonJS", "ES2020"],
+      default: "CommonJS",
+      description: "module type for generated SDK",
+    },
+  },
+  additionalProperties: false,
+  required: ["def", "outdir"],
+};
+
+const ajv = new Ajv({ allErrors: true, useDefaults: true, coerceTypes: true });
+
+export async function generate(opts) {
+  const valid = ajv.validate(schema, opts);
+  if (!valid) {
+    console.log(ajv.errors);
+    process.exit(1);
+  }
+
+  const isUrl =
+    opts.def.startsWith("http://") || opts.def.startsWith("https://");
+
+  if (!isUrl && !fs.existsSync(path.resolve(opts.def))) {
+    throw new Error("Invalid path.");
+  }
+
+  let doc = isUrl
+    ? await fetch(opts.def, {}).then((res) => res.json())
+    : JSON.parse(fs.readFileSync(path.resolve(opts.def), { encoding: "utf8" }));
+
+  if (opts.preProcessDef) {
+    const fn = Function("doc", opts.preProcessDef);
+    doc = fn(doc);
+  }
+
+  // https://apitools.dev/swagger-parser/docs/options.html
+  const api = await SwaggerParser.validate(doc);
+
+  // Ignore defs without operationId
+  for (let [p, v1] of Object.entries(api.paths)) {
+    for (let [m, v2] of Object.entries(v1)) {
+      if (
+        !getOperationId(v2) ||
+        opts.filterDef?.({ pathname: p, method: m }) === false
+      ) {
+        delete api.paths[p][m];
+      }
+    }
+  }
+
+  const optsTypeGet = "{headers?: {[k: string]: string}, strategy?: 'network'}";
+  const optsType = "{headers?: {[k: string]: string}, clearCache?: boolean}";
+
+  let routes = await Promise.all(
+    Object.keys(api.paths)
+      .sort()
+      .map(async (path) => {
+        let output = "";
+        if (api.paths[path].get) {
+          let responseType = await createResponseBodyType(
+            api.paths[path],
+            "get",
+            opts.throwOnNotOkayRes
+          );
+
+          let queryType = await createQueryType(api.paths[path].get.parameters);
+          const hasUrlParameters = (api.paths[path].get.parameters || []).some(
+            (x) => x.in === "path"
+          );
+
+          let getFcn = `${getOperationId(api.paths[path].get)}(
+        params${hasUrlParameters ? "" : "?"}: ${createParamType(path).type},
+        query?: ${queryType},
+        opts?: ${optsTypeGet}
+      ) : Promise<${responseType}> {
+        let path = "${convertPath(path)}";
+        return this._get(path, params, query, opts);
+      };`;
+
+          output += getFcn;
+        }
+
+        if (api.paths[path].post) {
+          const method = "post";
+          let requestBodyType = await createRequestBodyType(
+            api.paths[path],
+            method
+          );
+          const hasNoBody = requestBodyType.type === "undefined";
+          const requestBodyContentType = api.paths[path][method]?.requestBody
+            ? getRequestBodyContentType(api.paths[path], method)
+            : undefined;
+          let responseType = await createResponseBodyType(
+            api.paths[path],
+            method,
+            opts.throwOnNotOkayRes
+          );
+
+          // https://stackoverflow.com/a/35799817
+
+          let fcn = `${getOperationId(api.paths[path][method])}(
+        params: ${createParamType(path).type},
+        data${hasNoBody ? "?" : ""}: ${requestBodyType.type},
+        query?: ${await createQueryType(api.paths[path][method].parameters)},
+        opts?: ${optsType}
+      ) : Promise<${responseType}> {
+        let path = "${convertPath(path)}";
+        return this._${method}(path, params, data, query, opts, ${
+            requestBodyContentType === undefined ||
+            requestBodyContentType === "multipart/form-data"
+              ? "undefined"
+              : `"${requestBodyContentType}"`
+          });
+      };`;
+
+          output += fcn;
+        }
+
+        if (api.paths[path].patch) {
+          const method = "patch";
+          let requestBodyType = await createRequestBodyType(
+            api.paths[path],
+            method
+          );
+          const hasNoBody = requestBodyType.type === "undefined";
+          const requestBodyContentType = api.paths[path][method]?.requestBody
+            ? getRequestBodyContentType(api.paths[path], method)
+            : undefined;
+          let responseType = await createResponseBodyType(
+            api.paths[path],
+            method,
+            opts.throwOnNotOkayRes
+          );
+
+          // https://stackoverflow.com/a/35799817
+
+          let fcn = `${getOperationId(api.paths[path][method])}(
+        params: ${createParamType(path).type},
+        data${hasNoBody ? "?" : ""}: ${requestBodyType.type},
+        query?: ${await createQueryType(api.paths[path][method].parameters)},
+        opts?: ${optsType}
+      ) : Promise<${responseType}> {
+        let path = "${convertPath(path)}";
+        return this._${method}(path, params, data, query, opts, ${
+            requestBodyContentType === undefined ||
+            requestBodyContentType === "multipart/form-data"
+              ? "undefined"
+              : `"${requestBodyContentType}"`
+          });
+      };`;
+
+          output += fcn;
+        }
+
+        if (api.paths[path].put) {
+          const method = "put";
+          let requestBodyType = await createRequestBodyType(
+            api.paths[path],
+            method
+          );
+          const hasNoBody = requestBodyType.type === "undefined";
+          const requestBodyContentType = api.paths[path][method]?.requestBody
+            ? getRequestBodyContentType(api.paths[path], method)
+            : undefined;
+          let responseType = await createResponseBodyType(
+            api.paths[path],
+            method,
+            opts.throwOnNotOkayRes
+          );
+
+          // https://stackoverflow.com/a/35799817
+
+          let fcn = `${getOperationId(api.paths[path][method])}(
+        params: ${createParamType(path).type},
+        data${hasNoBody ? "?" : ""}: ${requestBodyType.type},
+        query?: ${await createQueryType(api.paths[path][method].parameters)},
+        opts?: ${optsType}
+      ) : Promise<${responseType}> {
+        let path = "${convertPath(path)}";
+        return this._${method}(path, params, data, query, opts, ${
+            requestBodyContentType === undefined ||
+            requestBodyContentType === "multipart/form-data"
+              ? "undefined"
+              : `"${requestBodyContentType}"`
+          });
+      };`;
+
+          output += fcn;
+        }
+
+        if (api.paths[path].delete) {
+          let responseType = await createResponseBodyType(
+            api.paths[path],
+            "delete",
+            opts.throwOnNotOkayRes
+          );
+          const hasUrlParameters = (
+            api.paths[path].delete.parameters || []
+          ).some((x) => x.in === "path");
+
+          let deleteFcn = `${getOperationId(api.paths[path].delete)}(
+        params${hasUrlParameters ? "" : "?"}: ${createParamType(path).type},
+        query?: ${await createQueryType(api.paths[path].delete.parameters)},
+        opts?: ${optsType}
+      ) : Promise<${responseType}> {
+        let path = "${convertPath(path)}";
+        return this._delete(path, params, query, opts);
+      };`;
+
+          output += deleteFcn;
+        }
+
+        return output;
+      })
+  );
+
+  const code = prettier.format(
+    getSDKCode(routes.join(" "), opts.throwOnNotOkayRes, opts.cacheType),
+    { parser: "typescript" }
+  );
+
+  const tsConfigJSON = {
+    compilerOptions: {
+      target: "ES2020",
+      module: opts.module,
+      moduleResolution: "node",
+      declaration: true,
+      outDir: "./dist",
+      forceConsistentCasingInFileNames: true,
+    },
+    include: ["index.ts"],
+  };
+
+  const typeScriptVersion = "4.5.5";
+
+  const packageJSON = {
+    name: "temp",
+    version: "1.0.0",
+    dependencies: {
+      "cross-fetch": "^3.1.5",
+      "node-cache": "^4.2.1",
+      qs: "^6.9.4",
+      "@types/qs": "^6.9.5",
+    },
+    devDependencies: {
+      "@types/node": "13.9.1",
+      typescript: typeScriptVersion,
+    },
+  };
+
+  const tmpDirPath = path.join(os.tmpdir(), `osg-${Date.now()}`);
+  fse.mkdirpSync(tmpDirPath);
+  fs.writeFileSync(path.join(tmpDirPath, "index.ts"), code);
+  fs.writeFileSync(
+    path.join(tmpDirPath, "package.json"),
+    JSON.stringify(packageJSON, null, 2)
+  );
+  fs.writeFileSync(
+    path.join(tmpDirPath, "tsconfig.json"),
+    JSON.stringify(tsConfigJSON, null, 2)
+  );
+  child_process.execSync("npm i", { cwd: tmpDirPath, stdio: "inherit" });
+
+  const buildOutputPath = path.join(tmpDirPath, "dist");
+  // const nccVersion = "0.33.1";
+  // child_process.execSync(
+  //   `npx --yes -p @vercel/ncc@${nccVersion} ncc build ./index.ts -o dist`,
+  //   { cwd: tmpDirPath, stdio: "inherit" }
+  // );
+  // TODO - remove if we get ncc build output to work with CRA build
+  child_process.execSync(`npx -p typescript@${typeScriptVersion} tsc`, {
+    cwd: tmpDirPath,
+    stdio: "inherit",
+  });
+  // Disable ESLint for the compiled file. Mainly for CRA.
+  prependFile.sync(
+    path.join(buildOutputPath, "index.js"),
+    `/* eslint-disable */\n\n`
+  );
+
+  const outdir = path.resolve(opts.outdir);
+  if (!fs.existsSync(outdir)) {
+    fse.mkdirpSync(outdir);
+  }
+
+  const isGeneratePackageMode = opts.packageName != null;
+
+  const distOutputPath = isGeneratePackageMode
+    ? path.join(outdir, "dist")
+    : outdir;
+
+  fse.copySync(buildOutputPath, distOutputPath);
+  fse.removeSync(tmpDirPath);
+
+  if (isGeneratePackageMode) {
+    const packageJSON = {
+      name: opts.packageName,
+      version: "1.0.0",
+      author: opts.packageAuthor ?? "",
+      license: "MIT",
+      description: opts.packageDescription ?? "",
+      main: "./dist/index.js",
+      types: "./dist/index.d.ts",
+    };
+    const gitignoreSource = `/node_modules
+/.pnp
+.pnp.js
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+.vscode
+`;
+    fs.writeFileSync(
+      path.join(outdir, "package.json"),
+      JSON.stringify(packageJSON, null, 2)
+    );
+    fs.writeFileSync(path.join(outdir, ".gitignore"), gitignoreSource);
+  }
+}
+
+function getSDKCode(
+  methods: string,
+  throwOnNotOkayRes: boolean,
+  cacheType: "memory" | "none"
+) {
+  const useMemoryCache = cacheType === "memory";
+  return `import "cross-fetch/polyfill";
+  import * as qs from "qs";
+  ${useMemoryCache ? `const NodeCache = require("node-cache");` : ""}
+
+  type Headers = { [k: string]: string };
+  
+  ${
+    throwOnNotOkayRes
+      ? `class CustomError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = this.constructor.name;
+    }
+  };
+  
+  export class SDKResponseError extends CustomError {
+    error: any;
+    status: number;
+
+    constructor(error, status) {
+      super("Bad response");
+      this.error = error;
+      this.status = status;
+    }
+  }
+  `
+      : ""
+  }
+
+  type QueryStringOpts = Parameters<typeof qs.stringify>[1]
+
+  export class SDK {
+    _baseUrl?: string;
+    _headers?: Headers;
+    _queryStringOpts?: QueryStringOpts;
+    ${useMemoryCache ? `_cache: InstanceType<typeof NodeCache>;` : ""}
+  
+    constructor(opts: { baseUrl: string; headers?: Headers, queryStringOpts?: QueryStringOpts }) {
+      this.__setBaseUrl(opts.baseUrl);
+      this._queryStringOpts = opts.queryStringOpts;
+      if (opts?.headers) {
+        this._headers = opts.headers ?? {};
+      }
+      ${
+        useMemoryCache
+          ? `this._cache = new NodeCache({
+        // 10 min
+        stdTTL: 600,
+        // 5 min
+        checkperiod: 300,
+      });`
+          : ""
+      }
+    }
+  
+    __setBaseUrl(baseUrl: string) {
+      this._baseUrl = baseUrl;
+    }
+  
+    __setHeaders(fn: any) {
+      this._headers = fn(this._headers);
+    }
+  
+    __clearCache() {
+      ${useMemoryCache ? `this._cache.flushAll();` : ""}
+    }
+  
+    ${methods}
+  
+    async _get(path, params, query, opts) {
+      const { hydratedPath } = findParamArguments(path, params);
+      const url = \`\${this._baseUrl}\${hydratedPath}\${generateQueryString(query, this._queryStringOpts)}\`;
+      const cacheKey = \`GET\${url}\`;
+  
+      ${
+        useMemoryCache
+          ? `if (opts?.strategy !== "network") {
+        const cached = this._cache.get(cacheKey);
+        if (cached !== undefined) {
+          return cached;
+        }
+      }`
+          : ""
+      }
+  
+      let headers = { "Content-Type": "application/json" };
+      if (this._headers) {
+        headers = { ...headers, ...this._headers };
+      }
+      if (opts?.headers) {
+        headers = { ...headers, ...opts.headers };
+      }
+  
+      let res = await fetch(url, { headers });
+  
+      const json = await res.json();
+  
+      if (!res.ok) {
+        ${
+          throwOnNotOkayRes
+            ? `throw new SDKResponseError(json, res.status);`
+            : `return { error: json, status: res.status };`
+        }
+      }
+  
+      const out = { data: json, status: res.status };
+      ${useMemoryCache ? `this._cache.set(cacheKey, out);` : ""}
+  
+      return out;
+    }
+  
+    async _post(path, params, data, query, opts, requestBodyContentType) {
+      const { hydratedPath } = findParamArguments(path, params);
+  
+      let headers = !requestBodyContentType ? {} : { "Content-Type": requestBodyContentType };
+      if (this._headers) {
+        headers = { ...headers, ...this._headers };
+      }
+      if (opts?.headers) {
+        headers = { ...headers, ...opts.headers };
+      }
+  
+      let res = await fetch(
+        \`\${this._baseUrl}\${hydratedPath}\${generateQueryString(query, this._queryStringOpts)}\`,
+        {
+          method: "POST",
+          headers,
+          body: requestBodyContentType === "application/json" ? JSON.stringify(data) : data,
+        }
+      );
+  
+      if (res.status === 204) {
+        ${
+          useMemoryCache
+            ? `if (opts?.clearCache !== false) {
+          this._cache.flushAll();
+        }`
+            : ""
+        }
+        return { data: undefined, status: res.status };
+      }
+  
+      const json = await res.json();
+  
+      if (!res.ok) {
+        ${
+          throwOnNotOkayRes
+            ? `throw new SDKResponseError(json, res.status);`
+            : `return { error: json, status: res.status };`
+        }
+      }
+  
+      ${
+        useMemoryCache
+          ? `if (opts?.clearCache !== false) {
+        this._cache.flushAll();
+      }`
+          : ""
+      }
+  
+      return { data: json, status: res.status };
+    }
+  
+    async _patch(path, params, data, query, opts, requestBodyContentType) {
+      const { hydratedPath } = findParamArguments(path, params);
+  
+      let headers = !requestBodyContentType ? {} : { "Content-Type": requestBodyContentType };
+      if (this._headers) {
+        headers = { ...headers, ...this._headers };
+      }
+      if (opts?.headers) {
+        headers = { ...headers, ...opts.headers };
+      }
+  
+      let res = await fetch(
+        \`\${this._baseUrl}\${hydratedPath}\${generateQueryString(query, this._queryStringOpts)}\`,
+        {
+          method: "PATCH",
+          headers,
+          body: requestBodyContentType === "application/json" ? JSON.stringify(data) : data,
+        }
+      );
+  
+      if (res.status === 204) {
+        ${
+          useMemoryCache
+            ? `if (opts?.clearCache !== false) {
+          this._cache.flushAll();
+        }`
+            : ""
+        }
+        return { data: undefined, status: res.status };
+      }
+  
+      const json = await res.json();
+  
+      if (!res.ok) {
+        ${
+          throwOnNotOkayRes
+            ? `throw new SDKResponseError(json, res.status);`
+            : `return { error: json, status: res.status };`
+        }
+      }
+  
+      ${
+        useMemoryCache
+          ? `if (opts?.clearCache !== false) {
+        this._cache.flushAll();
+      }`
+          : ""
+      }
+  
+      return { data: json, status: res.status };
+    }
+  
+    async _put(path, params, data, query, opts, requestBodyContentType) {
+      const { hydratedPath } = findParamArguments(path, params);
+  
+      let headers = !requestBodyContentType ? {} : { "Content-Type": requestBodyContentType };
+      if (this._headers) {
+        headers = { ...headers, ...this._headers };
+      }
+      if (opts?.headers) {
+        headers = { ...headers, ...opts.headers };
+      }
+  
+      let res = await fetch(
+        \`\${this._baseUrl}\${hydratedPath}\${generateQueryString(query, this._queryStringOpts)}\`,
+        {
+          method: "PUT",
+          headers,
+          body: requestBodyContentType === "application/json" ? JSON.stringify(data) : data,
+        }
+      );
+  
+      if (res.status === 204) {
+        ${
+          useMemoryCache
+            ? `if (opts?.clearCache !== false) {
+          this._cache.flushAll();
+        }`
+            : ""
+        }
+        return { data: undefined, status: res.status };
+      }
+  
+      const json = await res.json();
+  
+      if (!res.ok) {
+        ${
+          throwOnNotOkayRes
+            ? `throw new SDKResponseError(json, res.status);`
+            : `return { error: json, status: res.status };`
+        }
+      }
+  
+      ${
+        useMemoryCache
+          ? `if (opts?.clearCache !== false) {
+        this._cache.flushAll();
+      }`
+          : ""
+      }
+  
+      return { data: json, status: res.status };
+    }
+  
+    async _delete(path, params, query, opts) {
+      const { hydratedPath } = findParamArguments(path, params);
+  
+      let headers = { "Content-Type": "application/json" };
+      if (this._headers) {
+        headers = { ...headers, ...this._headers };
+      }
+      if (opts?.headers) {
+        headers = { ...headers, ...opts.headers };
+      }
+  
+      let res = await fetch(
+        \`\${this._baseUrl}\${hydratedPath}\${generateQueryString(query, this._queryStringOpts)}\`,
+        { method: "DELETE", headers }
+      );
+  
+      if (res.status === 204) {
+        ${
+          useMemoryCache
+            ? `if (opts?.clearCache !== false) {
+          this._cache.flushAll();
+        }`
+            : ""
+        }
+        return { data: undefined, status: res.status };
+      }
+  
+      const json = await res.json();
+  
+      if (!res.ok) {
+        ${
+          throwOnNotOkayRes
+            ? `throw new SDKResponseError(json, res.status);`
+            : `return { error: json, status: res.status };`
+        }
+      }
+  
+      ${
+        useMemoryCache
+          ? `if (opts?.clearCache !== false) {
+        this._cache.flushAll();
+      }`
+          : ""
+      }
+  
+      return { data: json, status: res.status };
+    }
+  }
+  
+  function findParamArguments(path, obj) {
+    let parts = path.split(/\\//);
+    let params = parts.filter((p) => p.length > 0 && p[0] === ":");
+    let args = params.map((p) => p.substring(1, p.length));
+    let out = {};
+    let hydratedPath = path;
+    if (obj) {
+      args.forEach((e) => {
+        out[e] = obj[e];
+        hydratedPath = hydratedPath.replace(\`:\${e}\`, obj[e]);
+      });
+    }
+  
+    return { args, out, hydratedPath };
+  }
+  
+  function generateQueryString(obj, _opts) {
+    let opts = { addQueryPrefix: true, encode: true };
+    if (_opts) {
+      opts = {...opts, ..._opts};
+    }
+    return qs.stringify(obj, opts);
+  }
+`;
+}
+
+function getRequestBodyContentType(operationDef: object, method: string) {
+  const content = operationDef?.[method]?.requestBody?.content;
+  if (content == null) {
+    throw new Error("No content: " + getOperationId(operationDef));
+  }
+  const keys = Object.keys(content);
+  if (keys.length === 0) {
+    throw new Error("No content type: " + getOperationId(operationDef));
+  }
+  if (keys.length > 1) {
+    throw new Error(
+      "More than 1 content type. Not allowed: " + getOperationId(operationDef)
+    );
+  }
+  return keys[0];
+}
+
+async function createRequestBodyType(operationDef: object, method: string) {
+  let typeName = capitalize(getOperationId(operationDef[method])) + "Body";
+
+  if (operationDef?.[method]?.requestBody == null) {
+    return { type: "undefined", name: "" };
+  }
+
+  if (
+    operationDef?.[method]?.requestBody?.content?.["application/json"] == null
+  ) {
+    return { type: "any", name: "" };
+  }
+
+  if (
+    operationDef?.[method]?.requestBody?.content?.["application/json"]
+      ?.schema == null ||
+    operationDef[method].requestBody.content["application/json"].schema
+      .length === 0
+  ) {
+    return { type: "object", name: "" };
+  }
+
+  const schema = toJsonSchema(
+    operationDef[method].requestBody.content["application/json"].schema
+  );
+  // Delete title, since if there's a title, json-schema-to-typescript
+  // generates references.
+  traverse(schema, {
+    cb: (schema) => {
+      if (schema.title) {
+        delete schema.title;
+      }
+    },
+  });
+
+  return {
+    type: (
+      await compile(schema, "IRootObject", {
+        bannerComment: "",
+        declareExternallyReferenced: false,
+      })
+    )
+      .replace(/export interface IRootObject/g, "")
+      .replace(/export type IRootObject =/g, "")
+      .replace(/};/g, "}")
+      .replace(
+        `/**\n * The request body is an empty object.\n */\n{}\n`,
+        "object"
+      ),
+    name: typeName,
+  };
+}
+
+function createParamType(path: string): { name: string; type: string } {
+  // TODO - use `parameters` instead
+  let params = findParamArguments(path);
+
+  if (params.args.length === 0) {
+    return { type: "null", name: "" };
+  }
+
+  return {
+    type: json2ts(JSON.stringify(params.out)).replace(
+      "interface IRootObject ",
+      ""
+    ),
+    name: "",
+  };
+}
+
+async function createQueryType(parameters) {
+  if (parameters == null) {
+    return "object";
+  }
+
+  const queryParameters = parameters.filter((x) => x.in === "query");
+
+  if (queryParameters.length === 0) {
+    return "object";
+  }
+
+  const schema = queryParameters.reduce(
+    (acc: { properties: { [k: string]: any }; required: string[] }, v) => {
+      acc.properties[v.name] = v.schema;
+      if (v.required) {
+        acc.required.push(v.name);
+      }
+      return acc;
+    },
+    { properties: {}, required: [] }
+  );
+
+  // Delete title, since if there's a title, json-schema-to-typescript
+  // generates references.
+  traverse(schema, {
+    cb: (schema) => {
+      if (schema.title) {
+        delete schema.title;
+      }
+    },
+  });
+
+  return (
+    await compile(schema, "IRootObject", {
+      bannerComment: "",
+      declareExternallyReferenced: false,
+    })
+  )
+    .replace("export interface IRootObject ", "")
+    .replace(
+      `/**\n * The request body is an empty object.\n */\n{}\n`,
+      "object"
+    )
+    .replace("[k: string]: any;", "");
+}
+
+async function createResponseBodyType(
+  operationDef: object,
+  method: string,
+  throwOnNotOkayRes: boolean
+) {
+  let responses = operationDef[method]?.responses ?? {};
+  let out = "";
+
+  for (let [status, response] of Object.entries(responses)) {
+    const _schema = (response as any)?.content?.["application/json"]?.schema;
+    const schema =
+      _schema == null ? _schema : toJsonSchema(_schema, { strictMode: false });
+    // Delete title, since if there's a title, json-schema-to-typescript
+    // generates references.
+    if (schema != null) {
+      traverse(schema, {
+        cb: (schema) => {
+          if (schema.title) {
+            delete schema.title;
+          }
+        },
+      });
+    }
+
+    let type =
+      schema == null
+        ? schema
+        : (
+            await compile(schema, "IRootObject", {
+              bannerComment: "",
+              declareExternallyReferenced: false,
+            })
+          )
+            .replace(/export interface IRootObject /g, "")
+            .replace("export type IRootObject =", "")
+            .trim();
+    if (type?.endsWith(";")) {
+      type = type.slice(0, -1);
+    }
+
+    const notOk = parseInt(status) >= 400;
+
+    if (throwOnNotOkayRes) {
+      if (notOk) {
+        continue;
+      } else {
+        out += `| {data: ${type}, status: number}`;
+      }
+    } else {
+      if (notOk) {
+        out += `| {error: ${type}, status: number}`;
+      } else {
+        out += `| {data: ${type}, error?: undefined, status: number}`;
+      }
+    }
+  }
+
+  if (!throwOnNotOkayRes) {
+    // TODO?
+    // if (!Object.keys(responses).some(x => parseInt(x) >= 400)) {
+    out += "| {error: {[k: string]: any}, status: number}";
+    // }
+  }
+
+  return out;
+}
+
+function getOperationId(x: any) {
+  return x?.["x-technicity-sdk-name"] ?? x?.["operationId"];
+}
+
+function findParamArguments(path: string) {
+  let parts = path.split(/\//);
+  let params = parts
+    .map((p) => (p.startsWith("{") ? `:${p.slice(1, p.length - 1)}` : p))
+    .filter((p) => p.length > 0 && p[0] === ":");
+  let args = params.map((p) => p.substring(1, p.length));
+  let out = {};
+  let hydratedPath = path;
+  args.forEach((e) => {
+    out[e] = e;
+    hydratedPath = hydratedPath.replace(`:${e}`, e);
+  });
+
+  return { args, out, hydratedPath };
+}
+
+function convertPath(p: string) {
+  return p
+    .split(/\//)
+    .map((p) => (p.startsWith("{") ? `:${p.slice(1, p.length - 1)}` : p))
+    .join("/");
+}
+
+function capitalize(s: string) {
+  if (typeof s !== "string") return "";
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}