@accelbyte/codegen 1.0.0-alpha.1

package/dist/accelbyte-codegen.js

@@ -0,0 +1,972 @@
+#!/usr/bin/env node
+
+'use strict';
+
+var yargs = require('yargs');
+var zod = require('zod');
+var fs = require('fs');
+var path = require('path');
+var SwaggerParser = require('@apidevtools/swagger-parser');
+var _ = require('lodash');
+var fastJsonPatch = require('fast-json-patch');
+var https = require('https');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var yargs__default = /*#__PURE__*/_interopDefaultLegacy(yargs);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var SwaggerParser__default = /*#__PURE__*/_interopDefaultLegacy(SwaggerParser);
+var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
+var https__namespace = /*#__PURE__*/_interopNamespace(https);
+
+const SwaggersConfig = zod.z.array(zod.z.array(zod.z.string()));
+class CliParser {
+  static _instance;
+  argv;
+  constructor(yargs) {
+    this.argv = yargs.parse();
+  }
+  static createInstance = (yargs) => {
+    CliParser._instance = new CliParser(yargs);
+    return CliParser._instance;
+  };
+  static instance = (yargs) => {
+    if (!CliParser._instance && yargs) {
+      return CliParser.createInstance(yargs);
+    }
+    return CliParser._instance;
+  };
+  static getConfigPath = () => {
+    return CliParser.instance().argv.config;
+  };
+  static getConfigFile = () => {
+    const configPath = CliParser.getConfigPath();
+    if (!configPath)
+      throw new Error("Missing config file");
+    const config = JSON.parse(fs__default["default"].readFileSync(configPath, "utf8"));
+    if (!SwaggersConfig.safeParse(config).success) {
+      throw new Error("Wrong config file format");
+    }
+    return config;
+  };
+  static getOutputPath = () => {
+    return CliParser.instance().argv.output;
+  };
+  static getSwaggersOutputPath = () => {
+    return CliParser.instance().argv.swaggersOutput;
+  };
+  static getResolvedSwaggersOutputPath = () => {
+    return path__namespace.resolve(CliParser.getSwaggersOutputPath());
+  };
+  static isAdmin = () => {
+    return CliParser.instance().argv.admin;
+  };
+}
+
+const getImportableVarMap = () => ({
+  "@accelbyte/sdk": ["CodeGenUtil", "SdkCache", "IResponse", "IResponseWithSync", "Validate"],
+  axios: ["AxiosRequestConfig", "AxiosResponse"],
+  zod: ["z"]
+});
+const makeNewImportVarMap = () => ({
+  axios: ["AxiosInstance"],
+  "@accelbyte/sdk": ["SDKRequestConfig"]
+});
+const generateImports = (body, importStatements) => {
+  const usedImportVarMap = makeNewImportVarMap();
+  const importableVarMap = getImportableVarMap();
+  for (const [moduleSource, importableVars] of Object.entries(importableVarMap)) {
+    for (const importableVar of importableVars) {
+      const importVarRegex = new RegExp(`(?<![\\d\\w_])${importableVar}(?![\\d\\w_])`);
+      if (body.match(importVarRegex)) {
+        usedImportVarMap[moduleSource] = [...usedImportVarMap[moduleSource] || [], importableVar];
+      }
+    }
+  }
+  const generatedImports = Object.keys(usedImportVarMap).sort().map((moduleSource) => `import { ${usedImportVarMap[moduleSource].sort().join(", ")} } from '${moduleSource}'`).join("\n");
+  return `${generatedImports}
+${importStatements.sort().join("\n")}`;
+};
+const templateClass = (className, body, importStatements) => `/**
+   * DON'T EDIT THIS FILE, it is AUTO GENERATED
+   */
+  ${generateImports(body, importStatements)}
+
+  export class ${className} {
+      // @ts-ignore
+      constructor(private axiosInstance: AxiosInstance, private namespace: string, private cache = false) {}
+  ${body}
+  }
+  `;
+
+const templateJsdocFile = (apiName, body) => `
+\`\`\`
+SDK.getService('${apiName}', authHeader):
+${body}
+
+\`\`\`
+`.replace(/, \)/g, ")").trim();
+
+class ParserUtils {
+  static parseQueryParamAttributeDefault = (name, definition) => {
+    const attrName = name.slice(name.lastIndexOf(".") + 1);
+    const defaultValue = definition.type === "string" ? `'${definition.default}'` : definition.default;
+    return `${attrName}: ${defaultValue}`;
+  };
+  static parseType = (type) => {
+    if (type === "integer")
+      return "number";
+    if (type === "array")
+      return "any[]";
+    return type;
+  };
+  static parseQueryParamsType = (queryParams) => {
+    return queryParams.map((p) => ParserUtils.parseAttributeType(p.name, p)).join(",");
+  };
+  static isAnyQueryParamRequired = (queryParams) => {
+    queryParams.forEach((p) => {
+      if (p.required) {
+        return true;
+      }
+    });
+    return false;
+  };
+  static parseQueryParamsDefault = (queryParams) => {
+    const result = queryParams.filter((p) => !!p.default).map((p) => ParserUtils.parseQueryParamAttributeDefault(p.name, p)).join(",");
+    return result ? `${result},` : "";
+  };
+  static parseBodyParamsImports = (bodyParams) => {
+    const ret = bodyParams.map((p) => {
+      if (p?.schema?.$ref)
+        return ParserUtils.parseRefImport(p.schema.$ref, p);
+      if (p?.schema?.items?.$ref)
+        return ParserUtils.parseRefImport(p.schema.items.$ref, p);
+      if (p?.$ref)
+        return ParserUtils.parseRefImport(p.$ref, p);
+      return null;
+    }).filter((p) => !!p);
+    return ret;
+  };
+  static parseImportDir = ($ref) => {
+    let ref = $ref.replace(".", "/");
+    if (ref[ref.length - 1] === "." || ref[ref.length - 1] === "/") {
+      ref = ref.slice(0, -1);
+    }
+    if (!ref.includes("/")) {
+      return "";
+    } else {
+      return ref.slice(0, ref.lastIndexOf("/")).replace("#", ".");
+    }
+  };
+  static parseRefImport = ($ref, p) => {
+    const type = ParserUtils.parseRefType($ref);
+    return `import { ${type} } from './definitions/${type}'`;
+  };
+  static parseRefType = ($ref) => {
+    let ref = $ref.replace(".", "/");
+    if (ref[ref.length - 1] === "." || ref[ref.length - 1] === "/") {
+      ref = ref.slice(0, -1);
+    }
+    const val = ref.slice(ref.lastIndexOf("/") + 1);
+    return ___default["default"].upperFirst(___default["default"].camelCase(val));
+  };
+  static parseAttributeType = (name, definition) => {
+    const required = definition.required ? "" : "?";
+    const attrName = name.slice(name.lastIndexOf(".") + 1);
+    if (definition.enums) {
+      const enums = definition.enums.map((enm) => definition.type === "string" ? `'${enm}'` : enm).join(" | ");
+      return `${attrName}${required}: ${enums}`;
+    }
+    if (definition.type && definition.type === "integer") {
+      return `${attrName}${required}: number`;
+    }
+    if (definition.type && definition.type === "array") {
+      return `${attrName}${required}: ${definition.items.type ?? "any"}[]`;
+    }
+    if (definition.type && definition.type) {
+      return `${attrName}${required}: ${definition.type} | null`;
+    }
+    return `${attrName}${required}: any`;
+  };
+  static parseBodyParamsType = (bodyParams) => {
+    const [p] = bodyParams;
+    if (!p)
+      return null;
+    if (bodyParams.length > 0 && p?.name !== "body" && !p?.schema) {
+      let retBodyParams = `{${bodyParams.map((p2) => ParserUtils.parseAttributeType(p2.name, p2)).join(",")}}`;
+      retBodyParams = retBodyParams.replace("file?: file", "file?: File");
+      return retBodyParams;
+    }
+    if (p?.schema?.type === "array" && !p?.schema?.items?.$ref) {
+      return `${p.schema.items.type ?? "any"}[]`;
+    }
+    if (p?.schema?.type === "array" && p?.schema?.items?.$ref) {
+      return `${ParserUtils.parseRefType(p.schema.items.$ref)}[]`;
+    }
+    if (p?.schema.$ref) {
+      return ParserUtils.parseRefType(p.schema.$ref);
+    }
+    if (p?.schema?.additionalProperties?.type === "object") {
+      return "any";
+    }
+    return null;
+  };
+  static get2xxResponse(methodEntity, path2) {
+    const keys = Object.keys(methodEntity);
+    let responseClass = null;
+    keys.forEach((key) => {
+      if (String(key).startsWith("2")) {
+        const sch = methodEntity[key].schema;
+        if (sch?.$ref) {
+          responseClass = ParserUtils.parseRefType(sch.$ref);
+        } else if (sch?.type === "array" && sch.items?.$ref) {
+          responseClass = ParserUtils.parseRefType(sch.items.$ref);
+          responseClass = `${responseClass}Array`;
+        } else ;
+      }
+    });
+    return responseClass;
+  }
+  static isFormUrlEncoded(httpMethod, contentTypes) {
+    if (!contentTypes || contentTypes.length < 1) {
+      return false;
+    }
+    if (!["post", "put", "patch"].includes(httpMethod)) {
+      return false;
+    }
+    return contentTypes.includes("application/x-www-form-urlencoded");
+  }
+  static getPathParams(parametersArray) {
+    if (!parametersArray) {
+      return [];
+    }
+    const res = [];
+    for (const p of parametersArray) {
+      if (p.in === "path") {
+        res.push(p);
+      }
+    }
+    return res;
+  }
+  static generateClassMethod(path2, parametersArray, httpMethod, className) {
+    let replacedIdsPath = path2;
+    if (parametersArray) {
+      for (const p of parametersArray) {
+        if (p.in === "path") {
+          replacedIdsPath = replacedIdsPath.replace("{" + p.name + "}", "By" + ParserUtils.toTitleCaseWord(p.name));
+          replacedIdsPath = replacedIdsPath.replace("/iam", "");
+          replacedIdsPath = replacedIdsPath.replace("/odin-config", "");
+        }
+      }
+    }
+    let classMethod = httpMethod + "/" + replacedIdsPath;
+    classMethod = ___default["default"].camelCase(classMethod);
+    classMethod = classMethod.replace("PublicNamespacesByNamespace", "");
+    classMethod = classMethod.replace("AdminNamespacesByNamespace", "Admin");
+    const searchWord = "NamespacesByNamespace";
+    const nsExistInsideMethod = classMethod.indexOf(searchWord) > 0 && classMethod.indexOf(searchWord) + searchWord.length < classMethod.length;
+    const excludedClasses = ["Policies"];
+    if (nsExistInsideMethod && !excludedClasses.includes(className)) {
+      classMethod = classMethod.replace(searchWord, "");
+    }
+    return classMethod;
+  }
+  static getBodyParams(parametersArray) {
+    if (!parametersArray)
+      return [];
+    if (!___default["default"].isArray(parametersArray) && parametersArray)
+      return [parametersArray].filter((p) => p.in === "body" || p.in === "formData");
+    return parametersArray.filter((p) => p.in === "body" || p.in === "formData");
+  }
+  static getQueryParameters(parametersArray) {
+    if (!parametersArray) {
+      return [];
+    }
+    const res = [];
+    for (const p of parametersArray) {
+      if (p.in === "query") {
+        res.push(p);
+      }
+    }
+    return res;
+  }
+  static mkdirIfNotExist(dirToCreate) {
+    if (!fs__default["default"].existsSync(dirToCreate)) {
+      fs__default["default"].mkdirSync(dirToCreate, { recursive: true });
+    }
+  }
+  static writeClassFile(distDir, apiName, apiBuffer, imports) {
+    const fileContent = templateClass(apiName, apiBuffer, imports);
+    fs__default["default"].writeFileSync(`${distDir}/${apiName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
+  }
+  static writeJsdocFile(distDir, nameArray, apiBuffer) {
+    const jsdocFile = templateJsdocFile(nameArray[0], apiBuffer);
+    fs__default["default"].writeFileSync(`${distDir}/docs/${nameArray[0]}.md`, jsdocFile);
+  }
+  static writeDefinitionFile(distDir, name, buffer) {
+    ParserUtils.mkdirIfNotExist(distDir);
+    fs__default["default"].writeFileSync(path__default["default"].join(distDir, `${name}.ts`), ParserUtils.prependCopyrightHeader(buffer));
+  }
+  static writeAllImportsFile(distDir, buffer, isAdminWebSdk) {
+    ParserUtils.mkdirIfNotExist(distDir);
+    fs__default["default"].writeFileSync(path__default["default"].join(distDir, `all-${isAdminWebSdk ? "admin" : "public"}-imports.ts`), ParserUtils.prependCopyrightHeader(buffer));
+  }
+  static toCamelCase(str) {
+    return str.split("/").map(function(word, index) {
+      if (index === 0) {
+        return word.toLowerCase();
+      }
+      return ParserUtils.toCamelCaseWord(word);
+    }).join("");
+  }
+  static toCamelCaseWord(word) {
+    if (!word) {
+      return "";
+    }
+    word = word.replace(/(-\w)/g, (m) => m[1].toUpperCase());
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  }
+  static toTitleCaseWord(word) {
+    if (!word) {
+      return "";
+    }
+    return word.replace(/\w\S*/g, (txt) => {
+      return txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
+    });
+  }
+  static applyPatchIfExists(swaggerFilePath, possibleSwaggerPatchFilePath, swaggerPatchedFilePath, swaggerPatchedDir) {
+    if (!fs__default["default"].existsSync(swaggerPatchedDir)) {
+      fs__default["default"].mkdirSync(swaggerPatchedDir, { recursive: true });
+    }
+    if (!fs__default["default"].existsSync(possibleSwaggerPatchFilePath)) {
+      fs__default["default"].copyFileSync(swaggerFilePath, swaggerPatchedFilePath);
+      return;
+    }
+    const swaggerContent = JSON.parse(fs__default["default"].readFileSync(swaggerFilePath, "utf8"));
+    const swaggerPatchFileContent = JSON.parse(fs__default["default"].readFileSync(possibleSwaggerPatchFilePath, "utf8"));
+    const { newDocument } = fastJsonPatch.applyPatch(swaggerContent, swaggerPatchFileContent);
+    fs__default["default"].writeFileSync(swaggerPatchedFilePath, JSON.stringify(newDocument, null, 2));
+  }
+  static mapKeys(map_) {
+    const methods_ = [];
+    for (const m in map_) {
+      methods_.push(m);
+    }
+    return methods_;
+  }
+  static getRelativePathToWebSdkSrcFolder(srcFolder, targetSrcFolder) {
+    const replaced = srcFolder.replace(/\\/g, "/");
+    return replaced.replace(/\\/g, "/").replace(targetSrcFolder, "./");
+  }
+  static prependCopyrightHeader = (content) => {
+    const currentYear = new Date().getFullYear();
+    return `/* 
+ * Copyright (c) 2022${currentYear > 2022 ? `-${currentYear}` : ""} AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+${content}`;
+  };
+}
+
+const templateJsdocMethod = (classMethod, httpMethod, path, pathParams, bodyParams, queryParams) => {
+  let jsdoc = "";
+  let methodSignature = "";
+  let newPath = path;
+  for (const p of pathParams) {
+    methodSignature += p.name + ", ";
+    newPath = newPath.replace("{" + p.name + "}", `' + ${p.name} + '`);
+    jsdoc += `
+   * @pathParam '${p.name}${p.required ? "" : "?"}' - ${p.description}`;
+  }
+  let payloads = "";
+  for (const p of bodyParams) {
+    methodSignature += p.name + ", ";
+    payloads += p.name;
+    jsdoc += `
+   * @payload '${p.name}${p.required ? "" : "?"}' - ${p.description} ${p?.schema?.properties ? "=> " + JSON.stringify(p.schema.properties) : ""}`;
+  }
+  for (const p of queryParams) {
+    const optionalMark = p.required ? "" : "?";
+    methodSignature += p.name + optionalMark + ", ";
+    jsdoc += `
+   * @queryParam '${p.name}${p.required ? "" : "?"}' - ${p.description}`;
+  }
+  let queryString = "";
+  for (const p of queryParams) {
+    queryString += `${p.name}=__&`;
+  }
+  queryString = queryString.length > 0 ? "?" + queryString : "";
+  return `
+  /**
+   * ${httpMethod.toUpperCase()} '${newPath}${queryString}' ${payloads ? "payload: '" + payloads + "'" : ""}
+   * ${jsdoc}
+   */
+  ${classMethod}(${methodSignature}): Promise
+`;
+};
+
+const templateMethod = (classMethod, description, httpMethod, path, pathParams, bodyParams, queryParams, isFormUrlEncoded, responseClass) => {
+  let methodSignature = "";
+  let newPath = `'${path}'`;
+  let dependencies = [];
+  for (const p of pathParams) {
+    const type = ParserUtils.parseType(p.type);
+    if (p.name !== "namespace") {
+      methodSignature += p.name + `:${type}, `;
+    }
+    const pName = p.name === "namespace" ? "this.namespace" : p.name;
+    if (path.match(`{${p.name}}`)) {
+      if (type === "string") {
+        newPath = `${newPath}.replace('{${p.name}}', ${pName})`;
+      } else {
+        newPath = `${newPath}.replace('{${p.name}}', String(${pName}))`;
+      }
+    }
+  }
+  let dataType = null;
+  if (httpMethod !== "get") {
+    dataType = ParserUtils.parseBodyParamsType(bodyParams);
+    dependencies = ParserUtils.parseBodyParamsImports(bodyParams);
+    methodSignature += dataType ? `data: ${dataType},` : "";
+  }
+  ParserUtils.isAnyQueryParamRequired(queryParams);
+  const queryParamsType = queryParams.length ? `queryParams${"?"}: {${ParserUtils.parseQueryParamsType(queryParams)}}` : "";
+  const queryParamsDefault = queryParams.length ? `const params = {${ParserUtils.parseQueryParamsDefault(queryParams)} ...queryParams} as SDKRequestConfig` : "const params = {} as SDKRequestConfig";
+  const isPostPutPatch = ["post", "put", "patch"].includes(httpMethod);
+  const isDelete = ["delete"].includes(httpMethod);
+  let dataPayload = "{params}";
+  const descriptionText = description ? `
+  /**
+   * ${(description || "").replace(/\n/g, "\n   * ")} 
+   */` : "";
+  let formPayloadString = "";
+  if (isFormUrlEncoded) {
+    formPayloadString = ``;
+    const params = "{ ...params, headers: { ...params.headers, 'content-type': 'application/x-www-form-urlencoded' } }";
+    dataPayload = dataType ? `CodeGenUtil.getFormUrlEncodedData(data), ${params}` : `null, ${params}`;
+  } else if (isPostPutPatch) {
+    dataPayload = dataType ? `data, {params}` : "null, {params}";
+  } else if (isDelete) {
+    dataPayload = dataType ? `{data, params}` : "{params}";
+  }
+  const isFileUpload = methodSignature.indexOf("data: {file") > -1;
+  const resolvedResponseClass = responseClass || "unknown";
+  const resolvedResponseClassValidated = responseClass || "z.unknown()";
+  const parameters = (queryParamsType ? `${methodSignature} ${queryParamsType}` : methodSignature).replace(/,\s*$/, "");
+  let methodImpl = "";
+  const isCacheFetch = ["get"].includes(httpMethod) && resolvedResponseClass !== "unknown";
+  const isCacheFetchUnknown = ["get"].includes(httpMethod) && resolvedResponseClass === "unknown";
+  const cachedFetchMethod = classMethod.replace("get", "fetch");
+  const deprecateTag = isCacheFetch ? `/**
+ * @deprecated Use "${cachedFetchMethod}()" instead.
+ */` : "";
+  let isGuardInvoked = false;
+  if (isCacheFetch) {
+    methodImpl = `${descriptionText}
+  ${cachedFetchMethod}<T = ${resolvedResponseClass}>(${parameters}): Promise<IResponseWithSync<T>> {
+    ${queryParamsDefault}
+    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
+    const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
+    
+    const res = () => Validate.responseType(() => resultPromise, ${resolvedResponseClassValidated})
+
+    if (!this.cache) {
+      return SdkCache.withoutCache(res)
+    }
+    const key = url + CodeGenUtil.hashCode(JSON.stringify({ params }))
+    return SdkCache.withCache(key, res)
+  }
+  `;
+    isGuardInvoked = true;
+  }
+  if (isCacheFetchUnknown) {
+    methodImpl = `${descriptionText}
+  ${cachedFetchMethod}(${parameters}): Promise<IResponseWithSync<unknown>> {
+    ${queryParamsDefault}
+    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
+    const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
+    
+    const res = () => Validate.responseType(() => resultPromise, z.unknown())
+
+    if (!this.cache) {
+      return SdkCache.withoutCache(res)
+    }
+    const key = url + CodeGenUtil.hashCode(JSON.stringify({ params }))
+    return SdkCache.withCache(key, res)
+  }
+  `;
+    isGuardInvoked = true;
+  }
+  const withTypeGuard = ["post", "put", "patch", "delete"].includes(httpMethod) && resolvedResponseClass !== "unknown";
+  if (withTypeGuard) {
+    methodImpl = `${descriptionText}
+  ${classMethod}<T = ${resolvedResponseClass}>(${parameters}): Promise<IResponse<T>> {
+    ${queryParamsDefault}
+    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
+    const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
+    
+    return Validate.responseType(() => resultPromise, ${resolvedResponseClassValidated})    
+  }
+  `;
+    isGuardInvoked = true;
+  }
+  const withTypeGuardUnknown = ["post", "put", "patch", "delete"].includes(httpMethod) && resolvedResponseClass === "unknown";
+  if (withTypeGuardUnknown) {
+    methodImpl = `${descriptionText}
+  ${classMethod}(${parameters}): Promise<IResponse<unknown>> {
+    ${queryParamsDefault}
+    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
+    const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
+    
+    return Validate.responseType(() => resultPromise, z.unknown())    
+  }
+  `;
+    isGuardInvoked = true;
+  }
+  if (!isGuardInvoked) {
+    methodImpl = `${descriptionText}
+      ${deprecateTag}
+  TODO_${classMethod}<T = ${resolvedResponseClass}>(${parameters}): Promise<AxiosResponse<T>> {
+    ${queryParamsDefault}
+    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
+    return this.axiosInstance.${httpMethod}(url, ${dataPayload})
+  }
+    `;
+  }
+  return [methodImpl, dependencies];
+};
+
+class TemplateZod {
+  duplicates;
+  duplicateFound = false;
+  importClasses = /* @__PURE__ */ new Set();
+  render = (name, definition, duplicates) => {
+    this.duplicates = duplicates;
+    const content = this.parseToZodSchema(definition, definition.required || []);
+    const containsRecursiveType = this.importClasses.has(name);
+    if (containsRecursiveType) {
+      this.importClasses.delete(name);
+    }
+    let imports = "";
+    for (const cl of Array.from(this.importClasses).sort()) {
+      imports += `  import { ${cl} } from './${cl}'
+`;
+    }
+    let exportedVariableString;
+    let exportedTypeString;
+    if (containsRecursiveType) {
+      exportedVariableString = `
+        export const ${name}: z.ZodType<${name}> = z.lazy(() =>
+          ${content.schemaString}
+        )
+      `;
+      exportedTypeString = `
+        export type ${name} = {
+          ${content.typeString}
+        }
+      `;
+    } else {
+      exportedVariableString = `export const ${name} = ${content.schemaString}`;
+      exportedTypeString = `export type ${name} = z.TypeOf<typeof ${name}>`;
+    }
+    const template = `import { z } from 'zod'
+  ${imports}
+
+  ${exportedVariableString}
+
+  ${exportedTypeString}
+  `;
+    return { buffer: template, duplicateFound: this.duplicateFound };
+  };
+  parseToZodSchema = (definition, requiredAttrs) => {
+    if (definition.additionalProperties) {
+      return this.parseToZodAttribute("", definition, []);
+    }
+    if (!definition.properties) {
+      return {
+        schemaString: "z.any()",
+        typeString: "any"
+      };
+    }
+    const properties = Object.entries(definition.properties);
+    const schemaFields = [];
+    const typeFields = [];
+    for (const property of properties) {
+      const [name, definition2] = property;
+      const result = this.parseToZodAttribute(name, definition2, requiredAttrs);
+      schemaFields.push(result.schemaString);
+      typeFields.push(result.typeString);
+    }
+    return {
+      schemaString: `z.object({${schemaFields.join(",")}})`,
+      typeString: typeFields.join(";")
+    };
+  };
+  parseToZodAttribute = (name, definition, requiredAttrs) => {
+    const isRequired = requiredAttrs.includes(name) || name === "";
+    const schemaRequired = isRequired ? "" : ".nullish()";
+    const typeRequired = isRequired ? "" : "?";
+    const typeNullishability = isRequired ? "" : " | null | undefined";
+    const schemaAttribute = name ? `'${name}':` : "";
+    const typeAttribute = name ? `'${name}'${typeRequired}:` : "";
+    const type = definition?.type;
+    if (type) {
+      if (type === "object" && definition.additionalProperties) {
+        const zodAttribute = this.parseToZodAttribute("", definition.additionalProperties, [""]);
+        return {
+          schemaString: `${schemaAttribute} z.record(${zodAttribute.schemaString})${schemaRequired}`,
+          typeString: `${typeAttribute} Record<string, ${zodAttribute.typeString}>${typeNullishability}`
+        };
+      }
+      if (type === "object" && !definition.additionalProperties && !name) {
+        return {
+          schemaString: `z.any()`,
+          typeString: "any"
+        };
+      }
+      if (type === "object" && !definition.additionalProperties) {
+        return {
+          schemaString: `${schemaAttribute} z.record(z.any())${schemaRequired}`,
+          typeString: `${typeAttribute} Record<string, any>${typeNullishability}`
+        };
+      }
+      if (type === "integer" || type === "number") {
+        const effectiveType = getZodNumberType(type);
+        return {
+          schemaString: `${schemaAttribute} z.${effectiveType.schemaString}()${schemaRequired}`,
+          typeString: `${typeAttribute} ${effectiveType.typeString}${typeNullishability}`
+        };
+      }
+      if (type === "array") {
+        const ref2 = definition.items?.$ref;
+        let model2;
+        if (ref2) {
+          const refType = ParserUtils.parseRefType(ref2);
+          this.importClasses.add(refType);
+          model2 = {
+            schemaString: refType,
+            typeString: refType
+          };
+        } else {
+          const items = definition.items;
+          model2 = this.parseEnumItems(items);
+        }
+        return {
+          schemaString: `${schemaAttribute} z.array(${model2.schemaString})${schemaRequired}`,
+          typeString: `${typeAttribute} ${model2.typeString}[]${typeNullishability}`
+        };
+      }
+      if (type !== "object") {
+        const result = extractEnumObject(type, isRequired, definition.enum);
+        return {
+          schemaString: `${schemaAttribute} ${result.schemaString}`,
+          typeString: `${typeAttribute} ${result.typeString}`
+        };
+      }
+    } else if (definition.properties) {
+      const result = this.parseToZodSchema(definition, requiredAttrs);
+      return {
+        schemaString: `${schemaAttribute} ${result.schemaString}${schemaRequired}`,
+        typeString: `${typeAttribute} ${result.typeString}${typeNullishability}`
+      };
+    }
+    const ref = definition.$ref;
+    let model = `z.record(z.any())`;
+    if (ref) {
+      model = ParserUtils.parseRefType(ref);
+      const fullModelName = ref.replace("#/definitions/", "");
+      this.duplicateFound = this.duplicates.has(fullModelName);
+      if (this.duplicateFound) {
+        model = this.duplicates.get(fullModelName);
+      }
+      this.importClasses.add(model);
+      model = `${model}`;
+    }
+    return {
+      schemaString: `${schemaAttribute} ${model}${schemaRequired}`,
+      typeString: `${typeAttribute} ${model}${typeNullishability}`
+    };
+  };
+  parseEnumItems = (items) => {
+    if (items.enum) {
+      const enumStr = items.enum.map((e) => {
+        return `"${e}"`;
+      });
+      return {
+        schemaString: `z.enum([${enumStr}])`,
+        typeString: `(${enumStr.join(" | ")})`
+      };
+    }
+    if (items.type === "object") {
+      return this.parseToZodSchema(items, items.required);
+    }
+    let effectiveType;
+    if (items.type === "integer" || items.type === "number") {
+      effectiveType = getZodNumberType(items.type);
+    } else {
+      effectiveType = { typeString: items.type, schemaString: items.type };
+    }
+    return {
+      schemaString: `z.${effectiveType.schemaString}()`,
+      typeString: effectiveType.typeString
+    };
+  };
+}
+class TemplateZodArray {
+  render = (name) => {
+    const cls = name.replace("Array", "");
+    const template = `import { z } from 'zod'
+  import { ${cls} } from './${cls}'
+  
+  export const ${name} = z.array(${cls})
+
+  export type ${name} = z.TypeOf<typeof ${name}>
+  `;
+    return template;
+  };
+}
+const getZodNumberType = (type) => {
+  if (type === "integer") {
+    return {
+      schemaString: "number().int",
+      typeString: "number"
+    };
+  }
+  return {
+    schemaString: type,
+    typeString: type
+  };
+};
+const extractEnumObject = (type, isRequired, enumArr) => {
+  const schemaRequired = isRequired ? "" : ".nullish()";
+  const typeNullishability = isRequired ? "" : " | null | undefined";
+  if (enumArr) {
+    const enumStr = enumArr.map((e) => {
+      return `"${e}"`;
+    });
+    return {
+      schemaString: `z.enum([${enumStr}])${schemaRequired}`,
+      typeString: `(${enumStr.join(" | ")}${typeNullishability})`
+    };
+  }
+  return {
+    schemaString: `z.${type}()${schemaRequired}`,
+    typeString: `${type}${typeNullishability}`
+  };
+};
+
+class CodeGenerator {
+  static getPatchedDir = () => path__default["default"].join(CliParser.getSwaggersOutputPath(), "patched");
+  static getGeneratedPublicFolder = () => `${CliParser.getOutputPath()}/generated-public`;
+  static getGeneratedAdminFolder = () => `${CliParser.getOutputPath()}/generated-admin`;
+  static iterateApi = (api) => {
+    const apiBufferByTag = {};
+    const jsDocApiBufferByTag = {};
+    const dependenciesByTag = {};
+    const classImports = {};
+    let arrayDefinitions = [];
+    for (const path2 in api.paths) {
+      const isAdminEndpoint = path2.indexOf("/admin/") > -1;
+      if (CliParser.isAdmin() && !isAdminEndpoint) {
+        continue;
+      } else if (!CliParser.isAdmin() && isAdminEndpoint) {
+        continue;
+      }
+      const entity = api.paths[path2];
+      const methods = ParserUtils.mapKeys(entity);
+      for (const httpMethod of methods) {
+        const e = entity[httpMethod];
+        const [tag] = e.tags;
+        const description = e.description;
+        const isDeprecated = e.deprecated;
+        const responseClass = ParserUtils.get2xxResponse(e.responses, path2);
+        const className = ___default["default"].upperFirst(___default["default"].camelCase(tag));
+        classImports[className] = classImports[className] ? classImports[className] : {};
+        if (!isDeprecated) {
+          if (responseClass) {
+            const importTypeClass = ParserUtils.parseRefType(responseClass);
+            classImports[className][importTypeClass] = `import { ${importTypeClass} } from './definitions/${importTypeClass}'`;
+          }
+          if (responseClass && responseClass.endsWith("Array")) {
+            arrayDefinitions.push(responseClass);
+          }
+          const isFormUrlEncoded = ParserUtils.isFormUrlEncoded(httpMethod, e.consumes);
+          const queryParams = ParserUtils.getQueryParameters(e.parameters);
+          const pathParams = ParserUtils.getPathParams(e.parameters);
+          const bodyParams = ParserUtils.getBodyParams(e.parameters);
+          const classMethod = ParserUtils.generateClassMethod(path2, e.parameters, httpMethod, className);
+          const baseAndPath = `${api.basePath ?? ""}${path2}`;
+          const [generatedMethodString, importStatements] = templateMethod(classMethod, description, httpMethod, baseAndPath, pathParams, bodyParams, queryParams, isFormUrlEncoded, responseClass);
+          apiBufferByTag[tag] = (apiBufferByTag[tag] || "") + generatedMethodString;
+          jsDocApiBufferByTag[tag] = (jsDocApiBufferByTag[tag] || "") + templateJsdocMethod(classMethod, httpMethod, path2, pathParams, bodyParams, queryParams);
+          dependenciesByTag[tag] = dependenciesByTag[tag] ? [.../* @__PURE__ */ new Set([...importStatements, ...dependenciesByTag[tag]])] : [...new Set(importStatements)];
+        }
+      }
+    }
+    arrayDefinitions = [...new Set(arrayDefinitions)];
+    return { apiBufferByTag, jsDocApiBufferByTag, dependenciesByTag, classImports, arrayDefinitions };
+  };
+  static main = async (nameArray) => {
+    const serviceName = nameArray[0];
+    const swaggerFile = nameArray[2];
+    const parser = new SwaggerParser__default["default"]();
+    const generatedFolder = CliParser.isAdmin() ? CodeGenerator.getGeneratedAdminFolder() : CodeGenerator.getGeneratedPublicFolder();
+    const DIST_DIR = `${generatedFolder}/${serviceName}`;
+    const DIST_DOCS_DIR = path__default["default"].join(DIST_DIR, "docs");
+    const DIST_DEFINITION_DIR = path__default["default"].join(DIST_DIR, "definitions");
+    const swaggerFilePath = `${CliParser.getSwaggersOutputPath()}/${swaggerFile}`;
+    const swaggerPatchedFilePath = `${CodeGenerator.getPatchedDir()}/${swaggerFile}`;
+    const swaggerPatchFilePath = `${swaggerFilePath}patch`;
+    ParserUtils.applyPatchIfExists(swaggerFilePath, swaggerPatchFilePath, swaggerPatchedFilePath, CodeGenerator.getPatchedDir());
+    const api = await parser.parse(swaggerPatchedFilePath);
+    const indexImportsSet = /* @__PURE__ */ new Set();
+    console.log("\n----------\n API name: %s, Version: %s schemes %s", api, api.info.title, api.info.version, api.schemes);
+    ParserUtils.mkdirIfNotExist(DIST_DIR);
+    ParserUtils.mkdirIfNotExist(DIST_DOCS_DIR);
+    ParserUtils.mkdirIfNotExist(DIST_DEFINITION_DIR);
+    const { apiBufferByTag, dependenciesByTag, classImports, arrayDefinitions } = CodeGenerator.iterateApi(api);
+    const targetSrcFolder = `${CliParser.getOutputPath()}/`;
+    for (const tag in apiBufferByTag) {
+      const className = ___default["default"].upperFirst(___default["default"].camelCase(tag));
+      const apiBuffer = apiBufferByTag[tag];
+      const imports = [.../* @__PURE__ */ new Set([...dependenciesByTag[tag], ...Object.values(classImports[className])])];
+      const classGenName = CliParser.isAdmin() ? className + "Admin$" : className + "$";
+      ParserUtils.writeClassFile(DIST_DIR, classGenName, apiBuffer, imports);
+      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default["default"].join(DIST_DIR, `${classGenName}`), targetSrcFolder));
+    }
+    const duplicates = /* @__PURE__ */ new Map();
+    for (const ref in api.definitions) {
+      const definition = api.definitions[ref];
+      let fileName = ParserUtils.parseRefType(ref);
+      const fileExist = fs__default["default"].existsSync(path__default["default"].join(DIST_DEFINITION_DIR, `${fileName}.ts`));
+      if (fileExist) {
+        fileName = ParserUtils.toCamelCaseWord(ref).replace(".", "").replace(".", "");
+        duplicates.set(ref, fileName);
+      }
+      const { buffer } = new TemplateZod().render(fileName, definition, /* @__PURE__ */ new Map());
+      ParserUtils.writeDefinitionFile(DIST_DEFINITION_DIR, fileName, buffer);
+      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default["default"].join(DIST_DEFINITION_DIR, fileName), targetSrcFolder));
+    }
+    for (const ref in api.definitions) {
+      const definition = api.definitions[ref];
+      const fileName = ParserUtils.parseRefType(ref);
+      const { buffer, duplicateFound } = new TemplateZod().render(fileName, definition, duplicates);
+      if (duplicateFound) {
+        ParserUtils.writeDefinitionFile(DIST_DEFINITION_DIR, fileName, buffer);
+        indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default["default"].join(DIST_DEFINITION_DIR, fileName), targetSrcFolder));
+      }
+    }
+    for (const arrayClass of arrayDefinitions) {
+      const buffer = new TemplateZodArray().render(arrayClass);
+      ParserUtils.writeDefinitionFile(DIST_DEFINITION_DIR, arrayClass, buffer);
+      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default["default"].join(DIST_DEFINITION_DIR, arrayClass), targetSrcFolder));
+    }
+    console.log("\n----------\nCOMPLETED.\n----------\n\n");
+    return indexImportsSet;
+  };
+}
+
+class SwaggerDownloader {
+  static getDestFile = (targetFileName) => {
+    const destPath = CliParser.getResolvedSwaggersOutputPath();
+    const destFile = path__namespace.join(destPath, targetFileName);
+    if (fs__namespace.existsSync(destFile))
+      return destFile;
+    if (!fs__namespace.existsSync(destPath))
+      fs__namespace.mkdirSync(destPath);
+    fs__namespace.writeFileSync(destFile, "");
+    return destFile;
+  };
+  static downloadFile = (targetFileName, url) => {
+    const destFile = SwaggerDownloader.getDestFile(targetFileName);
+    const file = fs__namespace.createWriteStream(destFile);
+    const request = https__namespace.get(url, function(response) {
+      response.pipe(file);
+      file.on("finish", () => {
+        file.close();
+        console.log(`SwaggerDownload ${url} completed`);
+      });
+    });
+    request.on("error", (err) => {
+      console.log(`SwaggerDownloader dl failed for "${targetFileName}" and "${url}"`, err);
+    });
+  };
+  static main = () => {
+    const swaggers = CliParser.getConfigFile();
+    for (const ref in swaggers) {
+      const targetFileName = swaggers[ref][2];
+      const url = swaggers[ref][3];
+      SwaggerDownloader.downloadFile(targetFileName, url);
+    }
+    console.log("\n----------\n SwaggerDownloader COMPLETED.\n----------\n\n");
+  };
+}
+
+yargs__default["default"].command("download-swaggers", "Download swaggers JSON files", (yargs2) => {
+  CliParser.createInstance(yargs2);
+  SwaggerDownloader.main();
+}).command("generate-code", "Generate code based on downloaded swagger files", async (yargs2) => {
+  yargs2.check(({ output, swaggersOutput }) => {
+    if (!output?.trim()) {
+      throw new Error("output is required for generate-code");
+    }
+    return true;
+  });
+  CliParser.createInstance(yargs2);
+  const arrayOfSets = await Promise.all(CliParser.getConfigFile().map((config) => CodeGenerator.main(config)));
+  const indexImportsSet = /* @__PURE__ */ new Set();
+  const filenamesSet = /* @__PURE__ */ new Set();
+  for (const set of arrayOfSets) {
+    set.forEach((value) => {
+      const fileName = path__default["default"].basename(value);
+      if (!filenamesSet.has(fileName)) {
+        indexImportsSet.add(value);
+        filenamesSet.add(fileName);
+      }
+    });
+  }
+  const indexImportsArray = Array.from(indexImportsSet);
+  const filesToImport = indexImportsArray.map((fileToImport) => {
+    return `export * from '${fileToImport.replace("\\", "/")}'`;
+  });
+  ParserUtils.writeAllImportsFile(CliParser.getOutputPath(), filesToImport.join("\n"), CliParser.isAdmin());
+}).option("config", {
+  description: "Config file providing backend services URL.",
+  type: "string",
+  demandOption: true
+}).option("swaggersOutput", {
+  description: "Output path for downloaded swaggers JSON files.",
+  type: "string",
+  demandOption: true
+}).option("output", {
+  description: "Output path for generated code. Required for generate-code",
+  type: "string"
+}).option("admin", {
+  description: "Only generate /admin endpoints.",
+  type: "boolean",
+  default: false,
+  demandOption: false
+}).demandCommand(1).help().argv;
+//# sourceMappingURL=accelbyte-codegen.js.map