@accelbyte/codegen 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/accelbyte-codegen.mjs

@@ -55,6 +55,9 @@ class CliParser {
   static getSnippetOutputPath = () => {
     return CliParser.instance().argv.snippetOutput;
   };
+  static skipVersionSync = () => {
+    return CliParser.instance().argv.skipVersionSync;
+  };
 }
 
 const getImportableVarMap$1 = () => ({
@@ -123,15 +126,25 @@ export function ${className}(sdk: AccelbyteSDK, args?: ApiArgs) {
   `;
 };
 
+const VersionBumpType = z.enum(["CUTOFF", "RELEASE", "HOTFIX"]);
 class VersionHelpers {
   static getNextVersion = ({
     codegenVersion,
     serviceVersion,
     predefinedMajorVersion,
-    predefinedMinorVersion,
+    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);
@@ -144,20 +157,39 @@ class VersionHelpers {
     if (sdkSemvers === null) {
       throw new Error(`Invalid sdk version: ${sdkVersion}`);
     }
-    const nextMajor = codegenSemvers.minor + predefinedMajorVersion;
-    const nextMinor = codegenSemvers.minor + predefinedMinorVersion;
-    const nextPatch = codegenSemvers.patch + serviceSemvers.patch;
-    const { major: currentMajor, minor: currentMinor, patch: currentPatch } = sdkSemvers;
+    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 || nextPatch !== currentPatch || nextMajor !== currentMajor) {
+      if (nextMinor !== currentMinor || nextMajor !== currentMajor) {
         nextVersion += `-${nextPrereleaseId}.0`;
       } else {
-        nextVersion += `-${sdkSemvers.prerelease.join(".")}`;
+        if (currentPrerelease.length)
+          nextVersion += `-${currentPrerelease.join(".")}`;
         nextVersion = semver.inc(nextVersion, "prerelease", void 0, nextPrereleaseId);
       }
     }
@@ -184,14 +216,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) => {
@@ -291,6 +323,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`;
     }
@@ -470,17 +508,16 @@ class ParserUtils {
     ParserUtils.mkdirIfNotExist(distDir);
     fs__default.writeFileSync(path__default.join(distDir, `all-${isAdminWebSdk ? "admin" : "public"}-imports.ts`), ParserUtils.prependCopyrightHeader(buffer));
   }
-  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);
     const nextSemver = VersionHelpers.getNextVersion({
       codegenVersion: codegenPackageJSON.version,
       serviceVersion: apiInfo["x-version"] || apiInfo.version || UNDEFINED_SWAGGER_SEMVER,
-      predefinedMajorVersion: packageJSON.predefinedMajorVersion,
-      predefinedMinorVersion: packageJSON.predefinedMinorVersion,
+      predefinedMajorVersion: packageJSON.predefinedMajorVersion || 0,
+      versionBumpType: process.env.VERSION_BUMP_TYPE,
       sdkVersion: packageJSON.version,
       nextPrereleaseId: prereleaseId
     });
@@ -564,7 +601,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) => {
@@ -632,205 +671,6 @@ const isSwaggerIntegerType = (type) => {
   return type === "integer" || type === "int";
 };
 
-const Schema = z.object({
-  $ref: z.string().nullish(),
-  type: z.union([z.literal("array"), z.literal("object"), z.literal("file"), z.literal("string"), z.literal("boolean"), z.literal("integer")]).nullish(),
-  items: z.object({
-    $ref: z.string().nullish(),
-    type: z.string().nullish()
-  }).nullish(),
-  properties: z.union([z.array(z.string()).nullish(), z.record(z.object({ type: z.string() })).nullish()]),
-  description: z.string().nullish(),
-  additionalProperties: z.object({
-    type: z.string().nullish()
-  }).nullish()
-});
-const Definition = z.object({
-  required: z.array(z.string()).nullish(),
-  properties: z.record(z.object({
-    type: z.string()
-  })).nullish()
-});
-const Definitions = z.record(Definition);
-const EndpointParametersType = z.enum(["apiKey", "boolean", "int", "integer", "number", "string", "array", "file"]);
-const EndpointParametersIn = z.enum(["body", "formData", "header", "path", "query"]);
-const EndpointParameters = z.object({
-  type: EndpointParametersType.nullish(),
-  description: z.string().nullish(),
-  name: z.string(),
-  in: EndpointParametersIn,
-  required: z.boolean().nullish(),
-  schema: Schema.nullish(),
-  default: z.union([z.boolean(), z.string(), z.number(), z.array(z.any())]).nullish(),
-  enum: z.array(z.union([z.boolean(), z.string(), z.number()])).nullish(),
-  items: z.object({
-    type: z.string(),
-    enum: z.array(z.any()).nullish()
-  }).nullish()
-});
-const Endpoint = z.object({
-  description: z.string().nullish(),
-  consumes: z.array(z.string()).nullish(),
-  produces: z.array(z.string()).nullish(),
-  tags: z.array(z.string()).nullish(),
-  summary: z.string().nullish(),
-  operationId: z.string(),
-  deprecated: z.boolean().nullish(),
-  responses: z.record(z.object({
-    description: z.string().nullish(),
-    schema: Schema.nullish(),
-    content: z.object({
-      "application/json": z.object({
-        schema: Schema.nullish()
-      })
-    }).nullish()
-  })),
-  parameters: z.array(EndpointParameters).nullish(),
-  requestBody: z.object({
-    required: z.boolean(),
-    content: z.object({
-      "application/json": z.object({
-        schema: Schema.nullish()
-      })
-    }).nullish()
-  }).nullish()
-});
-const Operation = z.object({
-  get: Endpoint.nullish(),
-  post: Endpoint.nullish(),
-  patch: Endpoint.nullish(),
-  delete: Endpoint.nullish(),
-  put: Endpoint.nullish()
-});
-const Paths = z.record(Operation);
-z.object({
-  paths: Paths,
-  definitions: Definitions,
-  basePath: z.string(),
-  info: z.object({
-    description: z.string(),
-    title: z.string(),
-    contact: z.object({
-      name: z.string(),
-      url: z.string(),
-      email: z.string()
-    }),
-    version: z.string()
-  }),
-  schemes: z.array(z.string()).nullish(),
-  components: 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;
@@ -915,7 +755,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 {
@@ -991,12 +837,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())`;
@@ -1083,6 +923,227 @@ const extractEnumObject = (type, isRequired, enumArr) => {
   };
 };
 
+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 = z.object({
+  $ref: z.string().nullish(),
+  type: z.union([z.literal("array"), z.literal("object"), z.literal("file"), z.literal("string"), z.literal("boolean"), z.literal("integer")]).nullish(),
+  items: z.object({
+    $ref: z.string().nullish(),
+    type: z.string().nullish()
+  }).nullish(),
+  properties: z.union([z.array(z.string()).nullish(), z.record(z.object({ type: z.string() })).nullish()]),
+  description: z.string().nullish(),
+  additionalProperties: z.object({
+    type: z.string().nullish()
+  }).nullish()
+});
+const Definition = z.object({
+  required: z.array(z.string()).nullish(),
+  properties: z.record(z.object({
+    type: z.string()
+  })).nullish()
+});
+const Definitions = z.record(Definition);
+const EndpointParametersType = z.enum(["apiKey", "boolean", "int", "integer", "number", "string", "array", "file"]);
+const EndpointParametersIn = z.enum(["body", "formData", "header", "path", "query"]);
+const EndpointParameters = z.object({
+  type: EndpointParametersType.nullish(),
+  description: z.string().nullish(),
+  name: z.string(),
+  in: EndpointParametersIn,
+  required: z.boolean().nullish(),
+  schema: Schema.nullish(),
+  default: z.union([z.boolean(), z.string(), z.number(), z.array(z.any())]).nullish(),
+  enum: z.array(z.union([z.boolean(), z.string(), z.number()])).nullish(),
+  items: z.object({
+    type: z.string(),
+    enum: z.array(z.any()).nullish()
+  }).nullish()
+});
+const Endpoint = z.object({
+  description: z.string().nullish(),
+  consumes: z.array(z.string()).nullish(),
+  produces: z.array(z.string()).nullish(),
+  tags: z.array(z.string()).nullish(),
+  summary: z.string().nullish(),
+  operationId: z.string(),
+  deprecated: z.boolean().nullish(),
+  responses: z.record(z.object({
+    description: z.string().nullish(),
+    schema: Schema.nullish(),
+    content: z.object({
+      "application/json": z.object({
+        schema: Schema.nullish()
+      })
+    }).nullish()
+  })),
+  parameters: z.array(EndpointParameters).nullish(),
+  requestBody: z.object({
+    required: z.boolean(),
+    content: z.object({
+      "application/json": z.object({
+        schema: Schema.nullish()
+      })
+    }).nullish()
+  }).nullish()
+});
+const Operation = z.object({
+  get: Endpoint.nullish(),
+  post: Endpoint.nullish(),
+  patch: Endpoint.nullish(),
+  delete: Endpoint.nullish(),
+  put: Endpoint.nullish()
+});
+const Paths = z.record(Operation);
+z.object({
+  paths: Paths,
+  definitions: Definitions,
+  basePath: z.string(),
+  info: z.object({
+    description: z.string(),
+    title: z.string(),
+    contact: z.object({
+      name: z.string(),
+      url: z.string(),
+      email: z.string()
+    }),
+    version: z.string()
+  }),
+  schemes: z.array(z.string()).nullish(),
+  components: 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,
@@ -1144,28 +1205,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:");
@@ -1205,21 +1244,33 @@ const normalizeMethodSnippet = (methodInput, splitWord) => {
 };
 
 const GIT_URL = "https://github.com/AccelByte/accelbyte-web-sdk/blob/main/packages";
-class CodeGenerator {
-  static getPatchedDir = () => path__default.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]);
@@ -1228,55 +1279,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) {
-          continue;
-        }
-        if (endpoint.deprecated) {
+        if (!endpoint.tags || 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);
@@ -1300,8 +1358,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,
@@ -1313,32 +1371,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__default.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();
@@ -1353,27 +1416,39 @@ class CodeGenerator {
     ParserUtils.mkdirIfNotExist(DIST_DIR);
     ParserUtils.mkdirIfNotExist(DIST_DEFINITION_DIR);
     ParserUtils.mkdirIfNotExist(DIST_ENDPOINTS_DIR);
-    ParserUtils.syncPackageVersion(apiInfo, 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__default.join(DIST_ENDPOINTS_DIR, `${classGenName}`), targetSrcFolder));
       indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default.join(DIST_DIR, `${apiGenName}`), targetSrcFolder));