@accelbyte/codegen 1.0.5 → 2.0.0-beta.10

package/dist/accelbyte-codegen.js

@@ -78,6 +78,9 @@ class CliParser {
   static getSnippetOutputPath = () => {
     return CliParser.instance().argv.snippetOutput;
   };
+  static skipVersionSync = () => {
+    return CliParser.instance().argv.skipVersionSync;
+  };
 }
 
 const getImportableVarMap$1 = () => ({
@@ -146,6 +149,79 @@ export function ${className}(sdk: AccelbyteSDK, args?: ApiArgs) {
   `;
 };
 
+const VersionBumpType = zod.z.enum(["CUTOFF", "RELEASE", "HOTFIX"]);
+class VersionHelpers {
+  static getNextVersion = ({
+    codegenVersion,
+    serviceVersion,
+    predefinedMajorVersion,
+    versionBumpType,
+    sdkVersion,
+    nextPrereleaseId
+  }) => {
+    if (versionBumpType !== void 0) {
+      const parsed = VersionBumpType.safeParse(versionBumpType);
+      if (!parsed.success) {
+        throw new Error(`Invalid process.env.VERSION_BUMP_TYPE: ${versionBumpType}`);
+      }
+      if ((parsed.data === "HOTFIX" || parsed.data === "RELEASE") && nextPrereleaseId) {
+        throw new Error(`process.env.PRERELEASE_ID should be empty when process.env.VERSION_BUMP_TYPE is "HOTFIX" or "PRELEASE".`);
+      }
+    }
+    const codegenSemvers = semver.parse(codegenVersion);
+    const serviceSemvers = semver.parse(serviceVersion);
+    const sdkSemvers = semver.parse(sdkVersion);
+    if (codegenSemvers === null) {
+      throw new Error(`Invalid codegen version: ${codegenVersion}`);
+    }
+    if (serviceSemvers === null) {
+      throw new Error(`Invalid service version: ${serviceVersion}`);
+    }
+    if (sdkSemvers === null) {
+      throw new Error(`Invalid sdk version: ${sdkVersion}`);
+    }
+    const { major: currentMajor, minor: currentMinor, patch: currentPatch, prerelease: currentPrerelease } = sdkSemvers;
+    const nextMajor = codegenSemvers.major + predefinedMajorVersion;
+    const shouldResetVersion = nextMajor !== currentMajor;
+    let nextMinor = currentMinor;
+    let nextPatch = currentPatch;
+    switch (versionBumpType) {
+      case VersionBumpType.Enum.CUTOFF: {
+        nextMinor++;
+        nextPatch = 0;
+        break;
+      }
+      case VersionBumpType.Enum.RELEASE:
+        break;
+      case VersionBumpType.Enum.HOTFIX: {
+        nextPatch++;
+        break;
+      }
+    }
+    if (shouldResetVersion) {
+      nextMinor = 0;
+      nextPatch = 0;
+    }
+    let nextVersion = [
+      codegenSemvers.major + predefinedMajorVersion,
+      nextMinor,
+      nextPatch
+    ].join(".");
+    if (nextPrereleaseId) {
+      if (nextMinor !== currentMinor || nextMajor !== currentMajor) {
+        nextVersion += `-${nextPrereleaseId}.0`;
+      } else {
+        if (currentPrerelease.length)
+          nextVersion += `-${currentPrerelease.join(".")}`;
+        nextVersion = semver.inc(nextVersion, "prerelease", void 0, nextPrereleaseId);
+      }
+    }
+    return nextVersion;
+  };
+}
+
+const codegenPackageJsonPath = path.join(__dirname, "../package.json");
+const codegenPackageJSON = JSON.parse(fs.readFileSync(codegenPackageJsonPath, "utf-8"));
 const UNDEFINED_SWAGGER_SEMVER = "0.0.0";
 const REMOVED_KEYWORDS = [
   "/admin/",
@@ -163,14 +239,14 @@ class ParserUtils {
   static replaceAll = (string, search, replace) => {
     return string.split(search).join(replace);
   };
-  static generateClassName = (tag) => {
+  static generateClassName = (tag, isAdmin) => {
     const className = _.upperFirst(_.camelCase(tag));
-    const classGenName = CliParser.isAdmin() ? className + "Admin$" : className + "$";
+    const classGenName = isAdmin ? className + "Admin$" : className + "$";
     return { className, classGenName };
   };
-  static generateApiName = (tag) => {
+  static generateApiName = (tag, isAdmin) => {
     const apiName = _.upperFirst(_.camelCase(tag));
-    const apiGenName = CliParser.isAdmin() ? apiName + "AdminApi" : apiName + "Api";
+    const apiGenName = isAdmin ? apiName + "AdminApi" : apiName + "Api";
     return { apiName, apiGenName };
   };
   static parseQueryParamAttributeDefault = (definition) => {
@@ -270,6 +346,12 @@ class ParserUtils {
     if (definition?.schema?.type && definition.schema.type === "array") {
       return `${attrName}${required}: ${definition.schema.items.type ?? "any"}[]`;
     }
+    if (definition.type && definition.type === "file") {
+      return `${attrName}${required}: File`;
+    }
+    if (definition?.schema?.type && definition.schema.type === "file") {
+      return `${attrName}${required}: File`;
+    }
     if (definition.type && definition.type) {
       return `${attrName}${required}: ${definition.type} | null`;
     }
@@ -449,42 +531,21 @@ class ParserUtils {
     ParserUtils.mkdirIfNotExist(distDir);
     fs.writeFileSync(path.join(distDir, `all-${isAdminWebSdk ? "admin" : "public"}-imports.ts`), ParserUtils.prependCopyrightHeader(buffer));
   }
-  static syncChangelog(packageVersion) {
-    const currDir = process.cwd();
-    const pathToChangelog = path.join(currDir, "./CHANGELOG.md");
-    let fileContent = fs.readFileSync(pathToChangelog, "utf-8");
-    const date = new Date().toISOString().slice(0, 10);
-    fileContent = "### " + packageVersion + " - " + date + `
-
-- code-generated update
-
-` + fileContent.trim();
-    fs.writeFileSync(pathToChangelog, fileContent, "utf-8");
-  }
-  static syncPackageVersion(apiInfo, isAdminWebSdk, prereleaseId) {
-    if (isAdminWebSdk) {
+  static syncPackageVersion(apiInfo, skipVersionSync, prereleaseId) {
+    if (skipVersionSync)
       return;
-    }
     const currDir = process.cwd();
     const { packageJSON, pathToPackageJSON } = ParserUtils.getPackageJSONInfo(currDir);
-    let swaggerVersion = apiInfo.version ? apiInfo.version : UNDEFINED_SWAGGER_SEMVER;
-    swaggerVersion = Number(swaggerVersion.replace(".", "").replace(".", ""));
-    swaggerVersion = isNaN(swaggerVersion) ? 0 : swaggerVersion;
-    const currentSemver = packageJSON.version;
-    const currentPrerelease = semver.prerelease(currentSemver);
-    let nextSemver = [semver.major(currentSemver), swaggerVersion, semver.patch(currentSemver)].join(".");
-    if (currentPrerelease) {
-      const [id, ...rest] = currentPrerelease;
-      nextSemver += `-${id}.${rest.join(".")}`;
-    }
-    if (!prereleaseId) {
-      nextSemver = semver.inc(nextSemver, "patch");
-    } else {
-      nextSemver = semver.inc(nextSemver, "prerelease", void 0, prereleaseId);
-    }
+    const nextSemver = VersionHelpers.getNextVersion({
+      codegenVersion: codegenPackageJSON.version,
+      serviceVersion: apiInfo["x-version"] || apiInfo.version || UNDEFINED_SWAGGER_SEMVER,
+      predefinedMajorVersion: packageJSON.predefinedMajorVersion || 0,
+      versionBumpType: process.env.VERSION_BUMP_TYPE,
+      sdkVersion: packageJSON.version,
+      nextPrereleaseId: prereleaseId
+    });
     packageJSON.version = nextSemver;
     fs.writeFileSync(pathToPackageJSON, JSON.stringify(packageJSON, null, 2));
-    ParserUtils.syncChangelog(packageJSON.version);
   }
   static getPackageJSONInfo(dir) {
     const pathToPackageJSON = path.join(dir, "./package.json");
@@ -563,7 +624,9 @@ class ParserUtils {
 ${content}`;
   };
   static sortPathParamsByPath = (pathParams, path2) => {
-    return pathParams.sort((a, b) => path2.indexOf(a.name) - path2.indexOf(b.name));
+    const params = path2.match(/{\w*}/g) || [];
+    const cleanParams = params.map((param) => param.replace("{", "").replace("}", ""));
+    return pathParams.sort((a, b) => cleanParams.indexOf(a.name) - cleanParams.indexOf(b.name));
   };
 }
 const mappedMethod = (httpMethod, isForm) => {
@@ -631,205 +694,6 @@ const isSwaggerIntegerType = (type) => {
   return type === "integer" || type === "int";
 };
 
-const Schema = zod.z.object({
-  $ref: zod.z.string().nullish(),
-  type: zod.z.union([zod.z.literal("array"), zod.z.literal("object"), zod.z.literal("file"), zod.z.literal("string"), zod.z.literal("boolean"), zod.z.literal("integer")]).nullish(),
-  items: zod.z.object({
-    $ref: zod.z.string().nullish(),
-    type: zod.z.string().nullish()
-  }).nullish(),
-  properties: zod.z.union([zod.z.array(zod.z.string()).nullish(), zod.z.record(zod.z.object({ type: zod.z.string() })).nullish()]),
-  description: zod.z.string().nullish(),
-  additionalProperties: zod.z.object({
-    type: zod.z.string().nullish()
-  }).nullish()
-});
-const Definition = zod.z.object({
-  required: zod.z.array(zod.z.string()).nullish(),
-  properties: zod.z.record(zod.z.object({
-    type: zod.z.string()
-  })).nullish()
-});
-const Definitions = zod.z.record(Definition);
-const EndpointParametersType = zod.z.enum(["apiKey", "boolean", "int", "integer", "number", "string", "array", "file"]);
-const EndpointParametersIn = zod.z.enum(["body", "formData", "header", "path", "query"]);
-const EndpointParameters = zod.z.object({
-  type: EndpointParametersType.nullish(),
-  description: zod.z.string().nullish(),
-  name: zod.z.string(),
-  in: EndpointParametersIn,
-  required: zod.z.boolean().nullish(),
-  schema: Schema.nullish(),
-  default: zod.z.union([zod.z.boolean(), zod.z.string(), zod.z.number(), zod.z.array(zod.z.any())]).nullish(),
-  enum: zod.z.array(zod.z.union([zod.z.boolean(), zod.z.string(), zod.z.number()])).nullish(),
-  items: zod.z.object({
-    type: zod.z.string(),
-    enum: zod.z.array(zod.z.any()).nullish()
-  }).nullish()
-});
-const Endpoint = zod.z.object({
-  description: zod.z.string().nullish(),
-  consumes: zod.z.array(zod.z.string()).nullish(),
-  produces: zod.z.array(zod.z.string()).nullish(),
-  tags: zod.z.array(zod.z.string()).nullish(),
-  summary: zod.z.string().nullish(),
-  operationId: zod.z.string(),
-  deprecated: zod.z.boolean().nullish(),
-  responses: zod.z.record(zod.z.object({
-    description: zod.z.string().nullish(),
-    schema: Schema.nullish(),
-    content: zod.z.object({
-      "application/json": zod.z.object({
-        schema: Schema.nullish()
-      })
-    }).nullish()
-  })),
-  parameters: zod.z.array(EndpointParameters).nullish(),
-  requestBody: zod.z.object({
-    required: zod.z.boolean(),
-    content: zod.z.object({
-      "application/json": zod.z.object({
-        schema: Schema.nullish()
-      })
-    }).nullish()
-  }).nullish()
-});
-const Operation = zod.z.object({
-  get: Endpoint.nullish(),
-  post: Endpoint.nullish(),
-  patch: Endpoint.nullish(),
-  delete: Endpoint.nullish(),
-  put: Endpoint.nullish()
-});
-const Paths = zod.z.record(Operation);
-zod.z.object({
-  paths: Paths,
-  definitions: Definitions,
-  basePath: zod.z.string(),
-  info: zod.z.object({
-    description: zod.z.string(),
-    title: zod.z.string(),
-    contact: zod.z.object({
-      name: zod.z.string(),
-      url: zod.z.string(),
-      email: zod.z.string()
-    }),
-    version: zod.z.string()
-  }),
-  schemes: zod.z.array(zod.z.string()).nullish(),
-  components: zod.z.object({
-    schemas: Definitions
-  }).nullish()
-});
-
-const templateMethod = ({
-  classMethod,
-  description,
-  httpMethod,
-  path,
-  pathParams,
-  bodyParams,
-  queryParams,
-  isFormUrlEncoded,
-  responseClass
-}) => {
-  let methodParams = "";
-  let methodParamsNoTypes = "";
-  let newPath = `'${path}'`;
-  let importStatements = [];
-  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path);
-  for (const pathParam of sortedPathParams) {
-    const type = ParserUtils.parseType(pathParam);
-    if (pathParam.name !== "namespace") {
-      methodParams += pathParam.name + `:${type}, `;
-      methodParamsNoTypes += pathParam.name + ", ";
-    }
-    const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
-    if (path.match(`{${pathParam.name}}`)) {
-      if (type === "string") {
-        newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
-      } else {
-        newPath = `${newPath}.replace('{${pathParam.name}}', String(${pName}))`;
-      }
-    }
-  }
-  let dataType = null;
-  if (httpMethod !== "get") {
-    dataType = ParserUtils.parseBodyParamsType(bodyParams);
-    importStatements = ParserUtils.parseBodyParamsImports(bodyParams);
-    methodParams += dataType ? `data: ${dataType},` : "";
-    methodParamsNoTypes += dataType ? `data,` : "";
-  }
-  const isAnyRequired = ParserUtils.isAnyQueryParamRequired(queryParams);
-  const queryParamsType = queryParams.length ? `queryParams${isAnyRequired ? "" : "?"}: {${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 = methodParams.indexOf("data: {file") > -1;
-  const resolvedResponseClass = responseClass || "unknown";
-  const resolvedResponseClassValidated = responseClass || "z.unknown()";
-  methodParams = (queryParamsType ? `${methodParams} ${queryParamsType}` : methodParams).replace(/,\s*$/, "");
-  methodParamsNoTypes = queryParamsType ? `${methodParamsNoTypes} queryParams` : methodParamsNoTypes;
-  let methodImpl = "";
-  const isCacheFetch = ["get"].includes(httpMethod) && resolvedResponseClass !== "unknown";
-  const cachedFetchMethod = classMethod;
-  const deprecateTag = isCacheFetch ? `/**
- * @deprecated Use "${classMethod}()" instead.
- */` : "";
-  const isGuardInvoked = ["get", "post", "put", "patch", "delete"].includes(httpMethod);
-  const methodName = httpMethod === "get" ? cachedFetchMethod : ["post", "put", "patch", "delete"].includes(httpMethod) ? classMethod : "";
-  const responseType = resolvedResponseClass !== "unknown" ? `${resolvedResponseClass}` : "unknown";
-  const generateMethodName = () => `${methodName}(${methodParams}): Promise<${responseSyncType}<${responseType}>>`;
-  const responseSyncType = httpMethod === "get" ? "IResponseWithSync" : ["post", "put", "patch", "delete"].includes(httpMethod) ? "IResponse" : "";
-  methodImpl = `${descriptionText}
-  ${generateMethodName()} {
-    ${queryParamsDefault}
-    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
-    const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
-
-${httpMethod === "get" ? `    const res = () => Validate.responseType(() => resultPromise, ${resolvedResponseClassValidated}, '${resolvedResponseClassValidated}')
-
-    if (!this.cache) {
-      return SdkCache.withoutCache(res)
-    }
-    const cacheKey = url + CodeGenUtil.hashCode(JSON.stringify({ params }))
-    return SdkCache.withCache(cacheKey, res)` : ""}${["post", "put", "patch", "delete"].includes(httpMethod) ? `    return Validate.responseType(() => resultPromise, ${resolvedResponseClassValidated}, '${resolvedResponseClassValidated}')` : ""}
-  }
-  `;
-  if (!isGuardInvoked) {
-    methodImpl = `${descriptionText}
-      ${deprecateTag}
-  TODO_${classMethod}(${methodParams}): Promise<AxiosResponse<${resolvedResponseClass}>> {
-    ${queryParamsDefault}
-    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
-    return this.axiosInstance.${httpMethod}(url, ${dataPayload})
-  }
-    `;
-  }
-  const res = {
-    methodImpl,
-    methodParams,
-    methodParamsNoTypes,
-    importStatements
-  };
-  return res;
-};
-
 class TemplateZod {
   duplicates;
   duplicateFound = false;
@@ -914,7 +778,13 @@ ${exportedTypeString}
     const schemaAttribute = name ? `'${name}':` : "";
     const typeAttribute = name ? `'${name}'${typeRequired}:` : "";
     const type = definition?.type;
-    if (type) {
+    if (definition.properties) {
+      const result = this.parseToZodSchema(definition, requiredAttrs);
+      return {
+        schemaString: `${schemaAttribute} ${result.schemaString}${schemaRequired}`,
+        typeString: `${typeAttribute} ${result.typeString}${typeNullishability}`
+      };
+    } else if (type) {
       if (type === "object" && definition.additionalProperties) {
         const zodAttribute = this.parseToZodAttribute("", definition.additionalProperties, [""]);
         return {
@@ -990,12 +860,6 @@ ${exportedTypeString}
           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())`;
@@ -1082,29 +946,250 @@ const extractEnumObject = (type, isRequired, enumArr) => {
   };
 };
 
-const templateApiMethod = ({
-  classMethod,
-  description,
-  httpMethod,
-  path,
-  pathParams,
-  bodyParams,
-  responseClass,
-  classGenName,
-  methodParams,
-  methodParamsNoTypes
-}) => {
-  let methodSignature = "";
-  let newPath = `'${path}'`;
-  let snippetSdk = "";
-  let snippetShell = "";
-  for (const pathParam of pathParams) {
-    const type = ParserUtils.parseType(pathParam);
-    if (pathParam.name !== "namespace") {
-      methodSignature += pathParam.name + `:${type}, `;
-    }
-    const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
-    if (path.match(`{${pathParam.name}}`)) {
+const templateApiIndex = (serviceName, serviceNameTitle, apiList) => {
+  let imports = "";
+  let returnStatement = "";
+  for (const cl of apiList) {
+    imports += `
+import { ${cl} } from './${serviceName}/${cl}.js'`;
+    returnStatement += `
+${cl}, `;
+  }
+  return `/**
+ * AUTO GENERATED
+ */
+${imports}
+
+const apis = {
+${returnStatement}
+}
+
+export const ${ParserUtils.convertDashesToTitleCase(serviceNameTitle)} = apis
+  `;
+};
+
+const Schema = zod.z.object({
+  $ref: zod.z.string().nullish(),
+  type: zod.z.union([zod.z.literal("array"), zod.z.literal("object"), zod.z.literal("file"), zod.z.literal("string"), zod.z.literal("boolean"), zod.z.literal("integer")]).nullish(),
+  items: zod.z.object({
+    $ref: zod.z.string().nullish(),
+    type: zod.z.string().nullish()
+  }).nullish(),
+  properties: zod.z.union([zod.z.array(zod.z.string()).nullish(), zod.z.record(zod.z.object({ type: zod.z.string() })).nullish()]),
+  description: zod.z.string().nullish(),
+  additionalProperties: zod.z.object({
+    type: zod.z.string().nullish()
+  }).nullish()
+});
+const Definition = zod.z.object({
+  required: zod.z.array(zod.z.string()).nullish(),
+  properties: zod.z.record(zod.z.object({
+    type: zod.z.string()
+  })).nullish()
+});
+const Definitions = zod.z.record(Definition);
+const EndpointParametersType = zod.z.enum(["apiKey", "boolean", "int", "integer", "number", "string", "array", "file"]);
+const EndpointParametersIn = zod.z.enum(["body", "formData", "header", "path", "query"]);
+const EndpointParameters = zod.z.object({
+  type: EndpointParametersType.nullish(),
+  description: zod.z.string().nullish(),
+  name: zod.z.string(),
+  in: EndpointParametersIn,
+  required: zod.z.boolean().nullish(),
+  schema: Schema.nullish(),
+  default: zod.z.union([zod.z.boolean(), zod.z.string(), zod.z.number(), zod.z.array(zod.z.any())]).nullish(),
+  enum: zod.z.array(zod.z.union([zod.z.boolean(), zod.z.string(), zod.z.number()])).nullish(),
+  items: zod.z.object({
+    type: zod.z.string(),
+    enum: zod.z.array(zod.z.any()).nullish()
+  }).nullish()
+});
+const Endpoint = zod.z.object({
+  description: zod.z.string().nullish(),
+  consumes: zod.z.array(zod.z.string()).nullish(),
+  produces: zod.z.array(zod.z.string()).nullish(),
+  tags: zod.z.array(zod.z.string()).nullish(),
+  summary: zod.z.string().nullish(),
+  operationId: zod.z.string(),
+  deprecated: zod.z.boolean().nullish(),
+  responses: zod.z.record(zod.z.object({
+    description: zod.z.string().nullish(),
+    schema: Schema.nullish(),
+    content: zod.z.object({
+      "application/json": zod.z.object({
+        schema: Schema.nullish()
+      })
+    }).nullish()
+  })),
+  parameters: zod.z.array(EndpointParameters).nullish(),
+  requestBody: zod.z.object({
+    required: zod.z.boolean(),
+    content: zod.z.object({
+      "application/json": zod.z.object({
+        schema: Schema.nullish()
+      })
+    }).nullish()
+  }).nullish()
+});
+const Operation = zod.z.object({
+  get: Endpoint.nullish(),
+  post: Endpoint.nullish(),
+  patch: Endpoint.nullish(),
+  delete: Endpoint.nullish(),
+  put: Endpoint.nullish()
+});
+const Paths = zod.z.record(Operation);
+zod.z.object({
+  paths: Paths,
+  definitions: Definitions,
+  basePath: zod.z.string(),
+  info: zod.z.object({
+    description: zod.z.string(),
+    title: zod.z.string(),
+    contact: zod.z.object({
+      name: zod.z.string(),
+      url: zod.z.string(),
+      email: zod.z.string()
+    }),
+    version: zod.z.string()
+  }),
+  schemes: zod.z.array(zod.z.string()).nullish(),
+  components: zod.z.object({
+    schemas: Definitions
+  }).nullish()
+});
+
+const templateMethod = ({
+  classMethod,
+  description,
+  httpMethod,
+  path,
+  pathParams,
+  bodyParams,
+  queryParams,
+  isFormUrlEncoded,
+  responseClass
+}) => {
+  let methodParams = "";
+  let methodParamsNoTypes = "";
+  let newPath = `'${path}'`;
+  let importStatements = [];
+  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path);
+  for (const pathParam of sortedPathParams) {
+    const type = ParserUtils.parseType(pathParam);
+    if (pathParam.name !== "namespace") {
+      methodParams += pathParam.name + `:${type}, `;
+      methodParamsNoTypes += pathParam.name + ", ";
+    }
+    const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
+    if (path.match(`{${pathParam.name}}`)) {
+      if (type === "string") {
+        newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
+      } else {
+        newPath = `${newPath}.replace('{${pathParam.name}}', String(${pName}))`;
+      }
+    }
+  }
+  let dataType = null;
+  if (httpMethod !== "get") {
+    dataType = ParserUtils.parseBodyParamsType(bodyParams);
+    importStatements = ParserUtils.parseBodyParamsImports(bodyParams);
+    methodParams += dataType ? `data: ${dataType},` : "";
+    methodParamsNoTypes += dataType ? `data,` : "";
+  }
+  const isAnyRequired = ParserUtils.isAnyQueryParamRequired(queryParams);
+  const queryParamsType = queryParams.length ? `queryParams${isAnyRequired ? "" : "?"}: {${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 = methodParams.indexOf("data: {file") > -1;
+  const resolvedResponseClass = responseClass || "unknown";
+  const resolvedResponseClassValidated = responseClass || "z.unknown()";
+  methodParams = (queryParamsType ? `${methodParams} ${queryParamsType}` : methodParams).replace(/,\s*$/, "");
+  methodParamsNoTypes = queryParamsType ? `${methodParamsNoTypes} queryParams` : methodParamsNoTypes;
+  let methodImpl = "";
+  const isCacheFetch = ["get"].includes(httpMethod) && resolvedResponseClass !== "unknown";
+  const cachedFetchMethod = classMethod;
+  const deprecateTag = isCacheFetch ? `/**
+ * @deprecated Use "${classMethod}()" instead.
+ */` : "";
+  const isGuardInvoked = ["get", "post", "put", "patch", "delete"].includes(httpMethod);
+  const methodName = httpMethod === "get" ? cachedFetchMethod : ["post", "put", "patch", "delete"].includes(httpMethod) ? classMethod : "";
+  const responseType = resolvedResponseClass !== "unknown" ? `${resolvedResponseClass}` : "unknown";
+  const generateMethodName = () => `${methodName}(${methodParams}): Promise<${responseSyncType}<${responseType}>>`;
+  const responseSyncType = httpMethod === "get" ? "IResponseWithSync" : ["post", "put", "patch", "delete"].includes(httpMethod) ? "IResponse" : "";
+  methodImpl = `${descriptionText}
+  ${generateMethodName()} {
+    ${queryParamsDefault}
+    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
+    const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
+
+${httpMethod === "get" ? `    const res = () => Validate.responseType(() => resultPromise, ${resolvedResponseClassValidated}, '${resolvedResponseClassValidated}')
+
+    if (!this.cache) {
+      return SdkCache.withoutCache(res)
+    }
+    const cacheKey = url + CodeGenUtil.hashCode(JSON.stringify({ params }))
+    return SdkCache.withCache(cacheKey, res)` : ""}${["post", "put", "patch", "delete"].includes(httpMethod) ? `    return Validate.responseType(() => resultPromise, ${resolvedResponseClassValidated}, '${resolvedResponseClassValidated}')` : ""}
+  }
+  `;
+  if (!isGuardInvoked) {
+    methodImpl = `${descriptionText}
+      ${deprecateTag}
+  TODO_${classMethod}(${methodParams}): Promise<AxiosResponse<${resolvedResponseClass}>> {
+    ${queryParamsDefault}
+    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
+    return this.axiosInstance.${httpMethod}(url, ${dataPayload})
+  }
+    `;
+  }
+  const res = {
+    methodImpl,
+    methodParams,
+    methodParamsNoTypes,
+    importStatements
+  };
+  return res;
+};
+
+const templateApiMethod = ({
+  classMethod,
+  description,
+  httpMethod,
+  path,
+  pathParams,
+  bodyParams,
+  responseClass,
+  classGenName,
+  methodParams,
+  methodParamsNoTypes
+}) => {
+  let methodSignature = "";
+  let newPath = `'${path}'`;
+  let snippetSdk = "";
+  let snippetShell = "";
+  for (const pathParam of pathParams) {
+    const type = ParserUtils.parseType(pathParam);
+    if (pathParam.name !== "namespace") {
+      methodSignature += pathParam.name + `:${type}, `;
+    }
+    const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
+    if (path.match(`{${pathParam.name}}`)) {
       if (type === "string") {
         newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
       } else {
@@ -1143,28 +1228,6 @@ const templateApiMethod = ({
   return [methodImpl, snippetSdk, snippetShell];
 };
 
-const templateApiIndex = (serviceName, serviceNameTitle, apiList) => {
-  let imports = "";
-  let returnStatement = "";
-  for (const cl of apiList) {
-    imports += `
-import { ${cl} } from './${serviceName}/${cl}.js'`;
-    returnStatement += `
-${cl}, `;
-  }
-  return `/**
- * AUTO GENERATED
- */
-${imports}
-
-const apis = {
-${returnStatement}
-}
-
-export const ${ParserUtils.convertDashesToTitleCase(serviceNameTitle)} = apis
-  `;
-};
-
 const templateSdkSnippet = (serviceNameTitle, apiName, methodSnippet) => {
   const methodArr = methodSnippet.split("//");
   let normMethod = normalizeMethodSnippet(methodArr[0].trim(), "data:");
@@ -1204,21 +1267,33 @@ const normalizeMethodSnippet = (methodInput, splitWord) => {
 };
 
 const GIT_URL = "https://github.com/AccelByte/accelbyte-web-sdk/blob/main/packages";
-class CodeGenerator {
-  static getPatchedDir = () => path.join(CliParser.getSwaggersOutputPath(), "patched");
-  static getGeneratedPublicFolder = () => `${CliParser.getOutputPath()}/generated-public`;
-  static getGeneratedAdminFolder = () => `${CliParser.getOutputPath()}/generated-admin`;
-  static getGeneratedSnippetsFolder = () => `${CliParser.getSnippetOutputPath()}/generated-snippets`;
+class SwaggerReaderHelpers {
   static getServicePrefix = (servicePaths) => servicePaths[servicePaths.length - 1].split("/")[1];
-  static iterateApi = async (api, serviceName) => {
-    const apiBufferByTag = {};
-    const apiArgumentsByTag = {};
-    const classBufferByTag = {};
-    const dependenciesByTag = {};
-    const classImports = {};
-    let arrayDefinitions = [];
-    const snippetMap = {};
-    const mapClassMethods = {};
+  static parseAllEndpoints = async ({
+    api,
+    sdkName,
+    serviceName
+  }) => {
+    const result = {
+      admin: {
+        arrayDefinitions: [],
+        snippetMap: {},
+        tagToClassImportsRecord: {},
+        tagToEndpointClassesRecord: {},
+        tagToSdkClientRecord: {},
+        tagToSdkFunctionNamesRecord: {},
+        tagToSdkImportsRecord: {}
+      },
+      public: {
+        arrayDefinitions: [],
+        snippetMap: {},
+        tagToClassImportsRecord: {},
+        tagToEndpointClassesRecord: {},
+        tagToSdkClientRecord: {},
+        tagToSdkFunctionNamesRecord: {},
+        tagToSdkImportsRecord: {}
+      }
+    };
     const sortedPathsByLength = new Map(Object.entries(api.paths).sort((a, b) => {
       if (a[0].length === b[0].length) {
         return a[0].localeCompare(b[0]);
@@ -1227,55 +1302,62 @@ class CodeGenerator {
       }
     }));
     const sortedKeys = Array.from(sortedPathsByLength.keys());
-    const servicePrefix = CodeGenerator.getServicePrefix(sortedKeys);
-    for (const [path2, operation] of sortedPathsByLength) {
-      const isAdminEndpoint = path2.indexOf("/admin/") > -1;
-      if (CliParser.isAdmin() && !isAdminEndpoint) {
-        continue;
-      } else if (!CliParser.isAdmin() && isAdminEndpoint) {
-        continue;
-      } else if (path2.indexOf("/healthz") >= 0) {
+    const servicePrefix = SwaggerReaderHelpers.getServicePrefix(sortedKeys);
+    const tagToClassMethodsMap = {
+      admin: {},
+      public: {}
+    };
+    for (const [path, operation] of sortedPathsByLength) {
+      if (path.indexOf("/healthz") >= 0) {
         continue;
       }
+      const isAdminEndpoint = path.indexOf("/admin/") > -1;
+      const picked = isAdminEndpoint ? result.admin : result.public;
+      const {
+        arrayDefinitions,
+        snippetMap,
+        tagToClassImportsRecord,
+        tagToEndpointClassesRecord,
+        tagToSdkClientRecord,
+        tagToSdkFunctionNamesRecord,
+        tagToSdkImportsRecord
+      } = picked;
+      const tagToClassMethodsMapByType = isAdminEndpoint ? tagToClassMethodsMap.admin : tagToClassMethodsMap.public;
       const httpMethods = Object.keys(operation);
       for (const httpMethod of httpMethods) {
         const endpoint = await Endpoint.parseAsync(operation[httpMethod]).catch((error) => {
-          console.error(JSON.stringify({ path: path2, httpMethod }, null, 2));
+          console.error(JSON.stringify({ path, httpMethod }, null, 2));
           throw error;
         });
-        if (!endpoint.tags) {
+        if (!endpoint.tags || endpoint.deprecated)
           continue;
-        }
-        if (endpoint.deprecated) {
-          continue;
-        }
         const [tag] = endpoint.tags;
-        mapClassMethods[tag] = mapClassMethods[tag] ? mapClassMethods[tag] : {};
+        const pathWithBase = `${api.basePath ?? ""}${path}`;
+        tagToClassMethodsMapByType[tag] = tagToClassMethodsMapByType[tag] ? tagToClassMethodsMapByType[tag] : {};
         const isForm = endpoint.consumes && endpoint.consumes[0] === "application/x-www-form-urlencoded";
         const classMethod = ParserUtils.generateNaturalLangMethod({
           servicePrefix,
-          path: path2,
+          path,
           httpMethod,
           isForm,
-          existingMethods: mapClassMethods[tag]
+          existingMethods: tagToClassMethodsMapByType[tag]
         });
-        mapClassMethods[tag][classMethod] = `${path2} ${httpMethod}`;
-        snippetMap[path2] = snippetMap[path2] ? snippetMap[path2] : {};
-        let description = endpoint.description;
-        description = description || "";
-        description = description.replace(/\s+/g, " ");
+        tagToClassMethodsMapByType[tag][classMethod] = `${path} ${httpMethod}`;
+        if (!snippetMap[pathWithBase]) {
+          snippetMap[pathWithBase] = {};
+        }
+        const description = endpoint.description?.replace(/\s+/g, " ") || "";
         const responseClass = ParserUtils.get2xxResponse(endpoint.responses);
-        const { className, classGenName } = ParserUtils.generateClassName(tag);
-        classImports[className] = classImports[className] ? classImports[className] : {};
+        const { className, classGenName } = ParserUtils.generateClassName(tag, isAdminEndpoint);
+        tagToClassImportsRecord[className] = tagToClassImportsRecord[className] ? tagToClassImportsRecord[className] : {};
         if (responseClass) {
           const importTypeClass = ParserUtils.parseRefType(responseClass);
-          classImports[className][importTypeClass] = `import { ${importTypeClass} } from '../definitions/${importTypeClass}.js'`;
+          tagToClassImportsRecord[className][importTypeClass] = `import { ${importTypeClass} } from '../definitions/${importTypeClass}.js'`;
         }
         if (responseClass && responseClass.endsWith("Array")) {
           arrayDefinitions.push(responseClass);
         }
         const queryParams = ParserUtils.filterQueryParameters(endpoint.parameters);
-        const pathWithBase = `${api.basePath ?? ""}${path2}`;
         const isFormUrlEncoded = ParserUtils.isFormUrlEncoded(httpMethod, endpoint.consumes);
         const pathParams = ParserUtils.filterPathParams(endpoint.parameters);
         let bodyParams = ParserUtils.filterBodyParams(endpoint.parameters);
@@ -1299,8 +1381,8 @@ class CodeGenerator {
           isFormUrlEncoded,
           responseClass
         });
-        classBufferByTag[tag] = (classBufferByTag[tag] || "") + methodImpl;
-        const [generatedMethodString1, snippetMethod, snippetShell] = templateApiMethod({
+        tagToEndpointClassesRecord[tag] = (tagToEndpointClassesRecord[tag] || "") + methodImpl;
+        const [generatedMethodString, snippetMethod, snippetShell] = templateApiMethod({
           classMethod,
           description,
           httpMethod,
@@ -1312,32 +1394,37 @@ class CodeGenerator {
           methodParams,
           methodParamsNoTypes
         });
-        apiBufferByTag[tag] = (apiBufferByTag[tag] || "") + generatedMethodString1;
-        apiArgumentsByTag[tag] = (apiArgumentsByTag[tag] || "") + classMethod + ",";
-        dependenciesByTag[tag] = dependenciesByTag[tag] ? [.../* @__PURE__ */ new Set([...importStatements, ...dependenciesByTag[tag]])] : [...new Set(importStatements)];
+        tagToSdkClientRecord[tag] = (tagToSdkClientRecord[tag] || "") + generatedMethodString;
+        tagToSdkFunctionNamesRecord[tag] = (tagToSdkFunctionNamesRecord[tag] || "") + classMethod + ",";
+        tagToSdkImportsRecord[tag] = tagToSdkImportsRecord[tag] ? [.../* @__PURE__ */ new Set([...importStatements, ...tagToSdkImportsRecord[tag]])] : [...new Set(importStatements)];
         const serviceNameTitle = ParserUtils.convertDashesToTitleCase(serviceName);
-        const { apiGenName } = ParserUtils.generateApiName(tag);
+        const { apiGenName } = ParserUtils.generateApiName(tag, isAdminEndpoint);
         const resultSnippet = templateSdkSnippet(serviceNameTitle, apiGenName, snippetMethod);
-        snippetMap[path2][httpMethod] = {
-          web: resultSnippet,
-          webGit: GIT_URL + `/sdk-${serviceName}/src/generated-public/${serviceName}/${apiGenName}.ts`,
-          shell: snippetShell
-        };
+        const currentSnippetMap = {};
+        snippetMap[pathWithBase][httpMethod] = currentSnippetMap;
+        if (!isAdminEndpoint) {
+          currentSnippetMap.web = !isAdminEndpoint ? resultSnippet : "";
+          currentSnippetMap.webGit = !isAdminEndpoint ? GIT_URL + `/sdk-${sdkName}/src/generated-public/${serviceName}/${apiGenName}.ts` : "";
+        }
+        currentSnippetMap.shell = snippetShell;
       }
     }
-    arrayDefinitions = [...new Set(arrayDefinitions)];
-    return {
-      apiArgumentsByTag,
-      apiBufferByTag,
-      classBufferByTag,
-      dependenciesByTag,
-      classImports,
-      arrayDefinitions,
-      snippetMap
-    };
+    for (const key in result) {
+      result[key].arrayDefinitions = Array.from(new Set(result[key].arrayDefinitions));
+    }
+    return result;
   };
+}
+
+class CodeGenerator {
+  static getPatchedDir = () => path.join(CliParser.getSwaggersOutputPath(), "patched");
+  static getGeneratedPublicFolder = () => `${CliParser.getOutputPath()}/generated-public`;
+  static getGeneratedAdminFolder = () => `${CliParser.getOutputPath()}/generated-admin`;
+  static getGeneratedSnippetsFolder = () => `${CliParser.getSnippetOutputPath()}/generated-snippets`;
+  static getServicePrefix = (servicePaths) => servicePaths[servicePaths.length - 1].split("/")[1];
   static main = async (nameArray) => {
     const serviceName = nameArray[0];
+    const sdkName = nameArray[1];
     const swaggerFile = nameArray[2];
     const parser = new SwaggerParser();
     const generatedFolder = CliParser.isAdmin() ? CodeGenerator.getGeneratedAdminFolder() : CodeGenerator.getGeneratedPublicFolder();
@@ -1347,31 +1434,44 @@ class CodeGenerator {
     const swaggerFilePath = `${CliParser.getSwaggersOutputPath()}/${swaggerFile}`;
     const api = await parser.parse(swaggerFilePath);
     const indexImportsSet = /* @__PURE__ */ new Set();
-    console.log("----------\nGenerating API:", { title: api.info.title, version: api.info.version });
+    const apiInfo = { ...api.info, "x-version": api["x-version"]?.version };
+    console.log("----------\nGenerating API:", { title: apiInfo.title, version: apiInfo.version });
     ParserUtils.mkdirIfNotExist(DIST_DIR);
     ParserUtils.mkdirIfNotExist(DIST_DEFINITION_DIR);
     ParserUtils.mkdirIfNotExist(DIST_ENDPOINTS_DIR);
-    ParserUtils.syncPackageVersion(api.info, CliParser.isAdmin(), process.env.PRERELEASE_ID);
-    const { apiArgumentsByTag, apiBufferByTag, classBufferByTag, dependenciesByTag, classImports, arrayDefinitions, snippetMap } = await CodeGenerator.iterateApi(api, serviceName);
+    ParserUtils.syncPackageVersion(apiInfo, CliParser.skipVersionSync(), process.env.PRERELEASE_ID);
+    const parsedInformation = await SwaggerReaderHelpers.parseAllEndpoints({ api, sdkName, serviceName });
+    const parsedInformationByType = CliParser.isAdmin() ? parsedInformation.admin : parsedInformation.public;
+    const {
+      arrayDefinitions,
+      tagToClassImportsRecord,
+      tagToEndpointClassesRecord,
+      tagToSdkClientRecord,
+      tagToSdkFunctionNamesRecord,
+      tagToSdkImportsRecord
+    } = parsedInformationByType;
     if (CliParser.getSnippetOutputPath()) {
       try {
-        ParserUtils.writeSnippetFile(CodeGenerator.getGeneratedSnippetsFolder(), api.info.title, JSON.stringify(snippetMap, null, 2));
+        ParserUtils.writeSnippetFile(CodeGenerator.getGeneratedSnippetsFolder(), api.info.title, JSON.stringify({
+          ...parsedInformation.public.snippetMap,
+          ...parsedInformation.admin.snippetMap
+        }, null, 2));
       } catch (err) {
         console.log("Generating snippets", err);
       }
     }
     const targetSrcFolder = `${CliParser.getOutputPath()}/`;
     const apiList = [];
-    for (const tag in classBufferByTag) {
-      const { className, classGenName } = ParserUtils.generateClassName(tag);
-      const classBuffer = classBufferByTag[tag];
-      const imports = [.../* @__PURE__ */ new Set([...dependenciesByTag[tag], ...Object.values(classImports[className])])];
-      const apiImports = [.../* @__PURE__ */ new Set([...dependenciesByTag[tag], ...Object.values(classImports[className])])];
+    for (const tag in tagToEndpointClassesRecord) {
+      const { className, classGenName } = ParserUtils.generateClassName(tag, CliParser.isAdmin());
+      const classBuffer = tagToEndpointClassesRecord[tag];
+      const imports = [.../* @__PURE__ */ new Set([...tagToSdkImportsRecord[tag], ...Object.values(tagToClassImportsRecord[className])])];
+      const apiImports = [.../* @__PURE__ */ new Set([...tagToSdkImportsRecord[tag], ...Object.values(tagToClassImportsRecord[className])])];
       apiImports.push(`import { ${classGenName} } from './endpoints/${classGenName}.js'`);
       ParserUtils.writeClassFile(DIST_ENDPOINTS_DIR, classGenName, classBuffer, imports);
-      const apiBuffer = apiBufferByTag[tag];
-      const { apiGenName } = ParserUtils.generateApiName(tag);
-      ParserUtils.writeApiFile(DIST_DIR, apiGenName, apiBuffer, apiImports, apiArgumentsByTag[tag]);
+      const apiBuffer = tagToSdkClientRecord[tag];
+      const { apiGenName } = ParserUtils.generateApiName(tag, CliParser.isAdmin());
+      ParserUtils.writeApiFile(DIST_DIR, apiGenName, apiBuffer, apiImports, tagToSdkFunctionNamesRecord[tag]);
       apiList.push(apiGenName);
       indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(DIST_ENDPOINTS_DIR, `${classGenName}`), targetSrcFolder));
       indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(DIST_DIR, `${apiGenName}`), targetSrcFolder));
@@ -1441,33 +1541,36 @@ class SwaggerDownloader {
       });
     });
   };
-  static downloadFile = (targetFileName, url) => {
+  static downloadFile = async (targetFileName, url) => {
     const destFile = SwaggerDownloader.getDestFile(targetFileName);
     let data = "";
-    const request = https__namespace.get(url, function(response) {
-      response.on("data", (chunk) => {
-        data += chunk;
+    return new Promise((resolve) => {
+      const request = https__namespace.get(url, function(response) {
+        response.on("data", (chunk) => {
+          data += chunk;
+        });
+        response.on("end", () => {
+          if (response.statusCode !== 200) {
+            console.log(`SwaggerDownload error with status code: ${response.statusCode}`);
+          } else {
+            fs__namespace.writeFileSync(destFile, JSON.stringify(JSON.parse(data), null, 2), "utf-8");
+            SwaggerDownloader.postSanitizeDownloadedFile(destFile);
+            console.log(`SwaggerDownload ${url} completed with status code: ${response.statusCode}`);
+          }
+          resolve(void 0);
+        });
       });
-      response.on("end", () => {
-        if (response.statusCode !== 200) {
-          console.log(`SwaggerDownload error with status code: ${response.statusCode}`);
-        } else {
-          fs__namespace.writeFileSync(destFile, JSON.stringify(JSON.parse(data), null, 2), "utf-8");
-          SwaggerDownloader.postSanitizeDownloadedFile(destFile);
-          console.log(`SwaggerDownload ${url} completed with status code: ${response.statusCode}`);
-        }
+      request.on("error", (err) => {
+        console.log(`SwaggerDownloader failed for "${targetFileName}" and "${url}"`, err);
       });
     });
-    request.on("error", (err) => {
-      console.log(`SwaggerDownloader failed for "${targetFileName}" and "${url}"`, err);
-    });
   };
-  static main = () => {
+  static main = async () => {
     const swaggers = CliParser.getConfigFile();
     for (const ref in swaggers) {
       const targetFileName = swaggers[ref][2];
       const url = swaggers[ref][3];
-      SwaggerDownloader.downloadFile(targetFileName, url);
+      await SwaggerDownloader.downloadFile(targetFileName, url);
     }
   };
 }