@technicity/openapi-sdk-generator 2.0.0

package/dist/generate.js

@@ -0,0 +1,763 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const child_process = require("child_process");
+const fetch = require("node-fetch");
+const json_schema_to_typescript_1 = require("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");
+exports.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 });
+async function generate(opts) {
+    const valid = ajv.validate(exports.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);
+    }
+}
+exports.generate = generate;
+function getSDKCode(methods, throwOnNotOkayRes, cacheType) {
+    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, method) {
+    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, method) {
+    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 json_schema_to_typescript_1.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) {
+    // 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, 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 json_schema_to_typescript_1.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, method, throwOnNotOkayRes) {
+    let responses = operationDef[method]?.responses ?? {};
+    let out = "";
+    for (let [status, response] of Object.entries(responses)) {
+        const _schema = response?.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 json_schema_to_typescript_1.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) {
+    return x?.["x-technicity-sdk-name"] ?? x?.["operationId"];
+}
+function findParamArguments(path) {
+    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) {
+    return p
+        .split(/\//)
+        .map((p) => (p.startsWith("{") ? `:${p.slice(1, p.length - 1)}` : p))
+        .join("/");
+}
+function capitalize(s) {
+    if (typeof s !== "string")
+        return "";
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+//# sourceMappingURL=generate.js.map