@accelbyte/codegen 1.0.0-alpha.8 → 1.0.0-beta.11

package/dist/accelbyte-codegen.mjs

@@ -1,12 +1,12 @@
 import yargs from 'yargs';
 import { z } from 'zod';
 import * as fs from 'fs';
-import fs__default from 'fs';
+import fs__default, { readFileSync, writeFileSync } from 'fs';
 import * as path from 'path';
 import path__default from 'path';
 import SwaggerParser from '@apidevtools/swagger-parser';
-import _ from 'lodash';
 import { applyPatch } from 'fast-json-patch';
+import _ from 'lodash';
 import * as https from 'https';
 
 const SwaggersConfig = z.array(z.array(z.string()));
@@ -51,17 +51,55 @@ class CliParser {
   static isAdmin = () => {
     return CliParser.instance().argv.admin;
   };
+  static getSnippetOutputPath = () => {
+    return CliParser.instance().argv.snippetOutput;
+  };
 }
 
-const getImportableVarMap = () => ({
+const getImportableVarMap$1 = () => ({
   "@accelbyte/sdk": ["CodeGenUtil", "SdkCache", "IResponse", "IResponseWithSync", "Validate"],
   axios: ["AxiosRequestConfig", "AxiosResponse"],
   zod: ["z"]
 });
-const makeNewImportVarMap = () => ({
+const makeNewImportVarMap$1 = () => ({
   axios: ["AxiosInstance"],
   "@accelbyte/sdk": ["SDKRequestConfig"]
 });
+const generateImports$1 = (body, importStatements) => {
+  const usedImportVarMap = makeNewImportVarMap$1();
+  const importableVarMap = getImportableVarMap$1();
+  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) => {
+  return `/**
+ * AUTO GENERATED
+ */
+${generateImports$1(body, importStatements)}
+
+export class ${className} {
+  // @ts-ignore
+  constructor(private axiosInstance: AxiosInstance, private namespace: string, private cache = false) {}
+  ${body}
+}
+  `;
+};
+
+const getImportableVarMap = () => ({
+  "@accelbyte/sdk": ["CodeGenUtil", "SdkCache", "IResponse", "IResponseWithSync", "Validate", "ApiArgs", "Network", "AccelbyteSDK"]
+});
+const makeNewImportVarMap = () => ({
+  "@accelbyte/sdk": ["AccelbyteSDK", "ApiArgs", "ApiUtils"]
+});
 const generateImports = (body, importStatements) => {
   const usedImportVarMap = makeNewImportVarMap();
   const importableVarMap = getImportableVarMap();
@@ -77,27 +115,55 @@ const generateImports = (body, importStatements) => {
   return `${generatedImports}
 ${importStatements.sort().join("\n")}`;
 };
-const templateClass = (className, body, importStatements) => `/**
-   * DON'T EDIT THIS FILE, it is AUTO GENERATED
-   */
-  ${generateImports(body, importStatements)}
+const templateApiClass = (className, body, importStatements, returnMethods) => {
+  return `/**
+ * AUTO GENERATED
+ */
+/* eslint-disable camelcase */
+${generateImports(body, importStatements)}
 
-  export class ${className} {
-      // @ts-ignore
-      constructor(private axiosInstance: AxiosInstance, private namespace: string, private cache = false) {}
+export function ${className}(sdk: AccelbyteSDK, args?: ApiArgs) {
+  const sdkAssembly = sdk.assembly()
+  
+  const namespace = args?.namespace ? args?.namespace : sdkAssembly.namespace
+  const cache = args?.cache ? args?.cache : sdkAssembly.cache
+  const requestConfig = ApiUtils.mergedConfigs(sdkAssembly.config, args)
   ${body}
+  
+  return {
+    ${returnMethods}
   }
+}
   `;
+};
 
-const templateJsdocFile = (apiName, body) => `
-\`\`\`
-SDK.getService('${apiName}', authHeader):
-${body}
-
-\`\`\`
-`.replace(/, \)/g, ")").trim();
-
+const UNDEFINED_SWAGGER_SEMVER = "0.0.0";
+const REMOVED_KEYWORDS = [
+  "/admin/",
+  "/public/",
+  "/v1/",
+  "/v2/",
+  "/v3/",
+  "/v4/",
+  "/v5/",
+  "/namespace/",
+  "/namespaces/",
+  "/{namespace}/"
+];
 class ParserUtils {
+  static replaceAll = (string, search, replace) => {
+    return string.split(search).join(replace);
+  };
+  static generateClassName = (tag) => {
+    const className = _.upperFirst(_.camelCase(tag));
+    const classGenName = CliParser.isAdmin() ? className + "Admin$" : className + "$";
+    return { className, classGenName };
+  };
+  static generateApiName = (tag) => {
+    const apiName = _.upperFirst(_.camelCase(tag));
+    const apiGenName = CliParser.isAdmin() ? apiName + "AdminApi" : apiName + "Api";
+    return { apiName, apiGenName };
+  };
   static parseQueryParamAttributeDefault = (definition) => {
     const attrName = definition.name.slice(definition.name.lastIndexOf(".") + 1);
     const defaultValue = definition.type === "string" ? `'${definition.default}'` : definition.default;
@@ -115,17 +181,26 @@ class ParserUtils {
     return pathParam.type;
   };
   static parseQueryParamsType = (queryParams) => {
-    return queryParams.map((queryParam) => ParserUtils.parseAttributeType(queryParam)).join(",");
+    return queryParams.map((queryParam) => ParserUtils.parseAttributeType(queryParam)).join(", ");
   };
   static isAnyQueryParamRequired = (queryParams) => {
     return queryParams.some((queryParam) => queryParam.required);
   };
+  static convertDashesToTitleCase = (str) => {
+    const result = str.split("-").map((word, index) => {
+      if (index === 0) {
+        return word.charAt(0).toUpperCase() + word.slice(1);
+      }
+      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    }).join("");
+    return result;
+  };
   static parseQueryParamsDefault = (queryParams) => {
     const result = queryParams.filter((queryParam) => !!queryParam.default && !queryParam.required).map(ParserUtils.parseQueryParamAttributeDefault).join(",");
     return result ? `${result},` : "";
   };
   static parseBodyParamsImports = (bodyParams) => {
-    return bodyParams.map(ParserUtils.parseRefImport).filter(Boolean);
+    return bodyParams.map((bodyParams2) => ParserUtils.parseRefImport(bodyParams2)).filter(Boolean);
   };
   static parseImportDir = ($ref) => {
     let ref = $ref.replace(".", "/");
@@ -144,7 +219,7 @@ class ParserUtils {
       return null;
     }
     const type = ParserUtils.parseRefType($ref);
-    return `import { ${type} } from './definitions/${type}'`;
+    return `import { ${type} } from '../definitions/${type}'`;
   };
   static parseRefType = ($ref) => {
     let ref = $ref.replace(".", "/");
@@ -238,34 +313,59 @@ class ParserUtils {
     }
     return parameters.filter((parameter) => parameter.in === "path");
   }
-  static generateClassMethod({
-    path: path2,
-    endpoint,
-    httpMethod,
-    className
-  }) {
-    let replacedIdsPath = path2;
-    if (endpoint.parameters) {
-      for (const parameter of endpoint.parameters) {
-        if (parameter.in === "path") {
-          replacedIdsPath = replacedIdsPath.replace("{" + parameter.name + "}", "By" + ParserUtils.toTitleCaseWord(parameter.name));
-          replacedIdsPath = replacedIdsPath.replace("/iam", "");
-          replacedIdsPath = replacedIdsPath.replace("/odin-config", "");
-        }
+  static generateNaturalLangMethod = ({ servicePrefix, path: path2, httpMethod, isForm, existingMethods }) => {
+    let path_ = path2;
+    path_ = path_.replace(`/${servicePrefix}/`, "/");
+    REMOVED_KEYWORDS.forEach((prefix) => {
+      path_ = path_.replace(prefix, "/");
+    });
+    path_ = path_.substring(1);
+    const isPlural = httpMethod === "get" && !(path2.slice(-1) === "}");
+    if (!isPlural) {
+      path_ = ParserUtils.replaceAll(path_, "ies/", "y/");
+      path_ = ParserUtils.replaceAll(path_, "s/", "/");
+      if (path_.indexOf("status") < 0) {
+        path_ = path_.replace(/ies$/, "y");
+        path_ = path_.replace(/s$/, "");
       }
     }
-    let classMethod = httpMethod + "/" + replacedIdsPath;
-    classMethod = _.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;
-  }
+    const arrLastWords = path_.split("}/");
+    let lastWords = arrLastWords[arrLastWords.length - 1];
+    const extractLastWord = (lastWords_) => {
+      let res = lastWords_;
+      res = res.split("/{")[0];
+      return res;
+    };
+    lastWords = extractLastWord(lastWords);
+    if (lastWords.indexOf("{") >= 0 && arrLastWords.length > 1) {
+      lastWords = arrLastWords[arrLastWords.length - 2];
+      lastWords = extractLastWord(lastWords);
+    }
+    const listBeforeLastWords = [];
+    let foundParam = false;
+    const listByParams = [];
+    const pathElements = path_.split("/");
+    pathElements.slice().reverse().forEach((item) => {
+      if (item.indexOf("}") >= 0) {
+        foundParam = true;
+        let param = item.replace("{", "");
+        param = param.replace("}", "");
+        param = "Byword" + _.upperFirst(param);
+        listByParams.push(param);
+      } else if (!foundParam) {
+        if (lastWords.indexOf(item) === -1) {
+          listBeforeLastWords.push(item);
+        }
+      } else {
+        foundParam = false;
+      }
+    });
+    const genPath = _.upperFirst(lastWords) + "/" + listBeforeLastWords.join("/") + listByParams.reverse().join("/");
+    let generatedMethod = _.camelCase(mappedMethod(httpMethod, isForm) + genPath);
+    generatedMethod = ParserUtils.replaceAll(generatedMethod, "Byword", "_By");
+    generatedMethod = resolveConflicts(path2, generatedMethod, existingMethods);
+    return generatedMethod;
+  };
   static filterBodyParams(parameters) {
     if (Array.isArray(parameters) && parameters.length > 0) {
       return parameters.filter((parameter) => parameter.in === "body" || parameter.in === "formData");
@@ -287,9 +387,22 @@ class ParserUtils {
     const fileContent = templateClass(apiName, apiBuffer, imports);
     fs__default.writeFileSync(`${distDir}/${apiName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
   }
-  static writeJsdocFile(distDir, nameArray, apiBuffer) {
-    const jsdocFile = templateJsdocFile(nameArray[0], apiBuffer);
-    fs__default.writeFileSync(`${distDir}/docs/${nameArray[0]}.md`, jsdocFile);
+  static writeApiFile(distDir, apiName, apiBuffer, imports, returnMethods) {
+    const newImports = [];
+    imports.forEach((el, index) => {
+      newImports.push(el.replace("../definitions", "./definitions"));
+    });
+    const fileContent = templateApiClass(apiName, apiBuffer, newImports, returnMethods);
+    fs__default.writeFileSync(`${distDir}/${apiName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
+  }
+  static writeApiMainFile(distDir, serviceName, fileContent) {
+    fs__default.writeFileSync(`${distDir}/${serviceName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
+  }
+  static writeSnippetFile(distDir, name, docBuffer) {
+    let snippetFileName = ParserUtils.replaceAll(name, " ", "-").toLowerCase();
+    snippetFileName = snippetFileName.replace("justice-", "");
+    snippetFileName = "snippet-" + snippetFileName + ".json";
+    fs__default.writeFileSync(`${distDir}/${snippetFileName}`, docBuffer);
   }
   static writeDefinitionFile(distDir, name, buffer) {
     ParserUtils.mkdirIfNotExist(distDir);
@@ -299,6 +412,37 @@ class ParserUtils {
     ParserUtils.mkdirIfNotExist(distDir);
     fs__default.writeFileSync(path__default.join(distDir, `all-${isAdminWebSdk ? "admin" : "public"}-imports.ts`), ParserUtils.prependCopyrightHeader(buffer));
   }
+  static syncChangelog(packageVersion) {
+    const currDir = process.cwd();
+    const pathToChangelog = path__default.join(currDir, "./CHANGELOG.md");
+    let fileContent = readFileSync(pathToChangelog, "utf-8");
+    const date = new Date().toISOString().slice(0, 10);
+    fileContent = "### " + packageVersion + " - " + date + `
+
+- code-generated update
+
+` + fileContent.trim();
+    fs__default.writeFileSync(pathToChangelog, fileContent, "utf-8");
+  }
+  static syncPackageVersion(apiInfo, isAdminWebSdk) {
+    if (isAdminWebSdk) {
+      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 semver = packageJSON.version.split(".").map((numStr) => Number(numStr));
+    const newSemver = [semver[0], swaggerVersion, ++semver[2]];
+    packageJSON.version = newSemver[0] + "." + newSemver[1] + "." + newSemver[2];
+    writeFileSync(pathToPackageJSON, JSON.stringify(packageJSON, null, 2));
+    ParserUtils.syncChangelog(packageJSON.version);
+  }
+  static getPackageJSONInfo(dir) {
+    const pathToPackageJSON = path__default.join(dir, "./package.json");
+    return { packageJSON: JSON.parse(readFileSync(pathToPackageJSON, "utf-8")), pathToPackageJSON };
+  }
   static toCamelCase(str) {
     return str.split("/").map(function(word, index) {
       if (index === 0) {
@@ -332,6 +476,29 @@ class ParserUtils {
     }
     const swaggerContent = JSON.parse(fs__default.readFileSync(swaggerFilePath, "utf8"));
     const swaggerPatchFileContent = JSON.parse(fs__default.readFileSync(possibleSwaggerPatchFilePath, "utf8"));
+    for (const patchEntry of swaggerPatchFileContent) {
+      const segments = patchEntry.path.split("/").filter(Boolean);
+      let currentNode = swaggerContent;
+      let aggregatedPath = "";
+      for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        aggregatedPath += `/${segment}`;
+        const effectiveSegment = segment.replace(/(~1)/g, "/").replace(/(~0)/g, "~");
+        if (!currentNode[effectiveSegment]) {
+          if (i + 1 === segments.length && patchEntry.op === "add") ; else {
+            throw new Error([
+              `JSON patch error: operation "${patchEntry.op}" on path "${aggregatedPath}" fails because the path doesn't exist in ${swaggerFilePath}. This may be caused by:
+`,
+              "1. The related service has patched the service, so patch is no longer needed.",
+              "2. There is a breaking change on the service that causes the path to change.\n",
+              `In any case, revisit this file: "${possibleSwaggerPatchFilePath}", then try again.
+`
+            ].join("\n"));
+          }
+        }
+        currentNode = currentNode[effectiveSegment];
+      }
+    }
     const { newDocument } = applyPatch(swaggerContent, swaggerPatchFileContent);
     fs__default.writeFileSync(swaggerPatchedFilePath, JSON.stringify(newDocument, null, 2));
   }
@@ -349,6 +516,67 @@ class ParserUtils {
 ${content}`;
   };
 }
+const mappedMethod = (httpMethod, isForm) => {
+  if (httpMethod === "get") {
+    return "get";
+  } else if (httpMethod === "post" && isForm) {
+    return "post";
+  } else if (httpMethod === "post") {
+    return "create";
+  } else if (httpMethod === "put") {
+    return "update";
+  } else if (httpMethod === "patch") {
+    return "patch";
+  } else if (httpMethod === "delete") {
+    return "delete";
+  }
+};
+const resolveConflicts = (path2, generatedMethod, existingMethods) => {
+  try {
+    testConflict(path2, generatedMethod, existingMethods);
+  } catch (e) {
+    if (path2.indexOf("/namespaces/") >= 0) {
+      generatedMethod += "_ByNS";
+    }
+  }
+  try {
+    testConflict(path2, generatedMethod, existingMethods);
+  } catch (e) {
+    if (path2.indexOf("/v4/") >= 0) {
+      generatedMethod += "_v4";
+    }
+  }
+  try {
+    testConflict(path2, generatedMethod, existingMethods);
+  } catch (e) {
+    if (path2.indexOf("/v3/") >= 0) {
+      generatedMethod += "_v3";
+    }
+  }
+  try {
+    testConflict(path2, generatedMethod, existingMethods);
+  } catch (e) {
+    if (path2.indexOf("/v2/") >= 0) {
+      generatedMethod += "_v2";
+    }
+  }
+  try {
+    testConflict(path2, generatedMethod, existingMethods);
+  } catch (e) {
+    if (path2.indexOf("/admin/") >= 0) {
+      generatedMethod += "_admin";
+    }
+  }
+  testConflict(path2, generatedMethod, existingMethods);
+  return generatedMethod;
+};
+const testConflict = (path2, generatedMethod, existingMethods) => {
+  if (existingMethods[generatedMethod]) {
+    const conflictingMethod = { path: path2, generatedMethod };
+    throw Error(`Duplicate method conflict in ${JSON.stringify(conflictingMethod)},
+ existingMethods: ${JSON.stringify(existingMethods, null, 2)}`);
+  }
+};
 
 const Schema = z.object({
   $ref: z.string().nullish(),
@@ -440,50 +668,6 @@ z.object({
   }).nullish()
 });
 
-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,
@@ -495,13 +679,17 @@ const templateMethod = ({
   isFormUrlEncoded,
   responseClass
 }) => {
-  let methodSignature = "";
+  let methodParams = "";
+  let methodParamsNoTypes = "";
   let newPath = `'${path}'`;
-  let dependencies = [];
+  let importStatements = [];
+  let snippetString = "";
+  let snippetMethodSignature = "";
   for (const pathParam of pathParams) {
     const type = ParserUtils.parseType(pathParam);
     if (pathParam.name !== "namespace") {
-      methodSignature += pathParam.name + `:${type}, `;
+      methodParams += pathParam.name + `:${type}, `;
+      methodParamsNoTypes += pathParam.name + ", ";
     }
     const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
     if (path.match(`{${pathParam.name}}`)) {
@@ -515,8 +703,16 @@ const templateMethod = ({
   let dataType = null;
   if (httpMethod !== "get") {
     dataType = ParserUtils.parseBodyParamsType(bodyParams);
-    dependencies = ParserUtils.parseBodyParamsImports(bodyParams);
-    methodSignature += dataType ? `data: ${dataType},` : "";
+    importStatements = ParserUtils.parseBodyParamsImports(bodyParams);
+    methodParams += dataType ? `data: ${dataType},` : "";
+    methodParamsNoTypes += dataType ? `data,` : "";
+    const snippetParams = bodyParams?.map((ob) => {
+      return ` <span class='sn-purple'>${ob.name}</span>`;
+    });
+    snippetMethodSignature += snippetParams ? `data: { ${snippetParams} }` : "";
+    bodyParams?.map((ob) => {
+      return ` <span class='sn-purple'>"${ob.name}": ""</span>`;
+    });
   }
   const isAnyRequired = ParserUtils.isAnyQueryParamRequired(queryParams);
   const queryParamsType = queryParams.length ? `queryParams${isAnyRequired ? "" : "?"}: {${ParserUtils.parseQueryParamsType(queryParams)}}` : "";
@@ -526,7 +722,7 @@ const templateMethod = ({
   let dataPayload = "{params}";
   const descriptionText = description ? `
   /**
-   * ${(description || "").replace(/\n/g, "\n   * ")} 
+   * ${description.replace(/\n/g, "\n   * ")} 
    */` : "";
   let formPayloadString = "";
   if (isFormUrlEncoded) {
@@ -538,47 +734,57 @@ const templateMethod = ({
   } else if (isDelete) {
     dataPayload = dataType ? `{data, params}` : "{params}";
   }
-  const isFileUpload = methodSignature.indexOf("data: {file") > -1;
+  const isFileUpload = methodParams.indexOf("data: {file") > -1;
   const resolvedResponseClass = responseClass || "unknown";
   const resolvedResponseClassValidated = responseClass || "z.unknown()";
-  const parameters = (queryParamsType ? `${methodSignature} ${queryParamsType}` : methodSignature).replace(/,\s*$/, "");
+  methodParams = (queryParamsType ? `${methodParams} ${queryParamsType}` : methodParams).replace(/,\s*$/, "");
+  methodParamsNoTypes = queryParamsType ? `${methodParamsNoTypes} queryParams` : methodParamsNoTypes;
   let methodImpl = "";
   const isCacheFetch = ["get"].includes(httpMethod) && resolvedResponseClass !== "unknown";
-  const cachedFetchMethod = classMethod.replace("get", "fetch");
+  const cachedFetchMethod = classMethod;
   const deprecateTag = isCacheFetch ? `/**
- * @deprecated Use "${cachedFetchMethod}()" instead.
+ * @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 methodGenerics = resolvedResponseClass !== "unknown" ? `<T = ${resolvedResponseClass}>` : "";
-  const responseType = resolvedResponseClass !== "unknown" ? `T` : "unknown";
+  const responseType = resolvedResponseClass !== "unknown" ? `${resolvedResponseClass}` : "unknown";
+  const generateMethodName = () => `${methodName}(${methodParams}): Promise<${responseSyncType}<${responseType}>>`;
+  const generateSnippetMethodName = () => `${methodName}(${snippetMethodSignature})`;
+  snippetString += `${generateSnippetMethodName()}`;
   const responseSyncType = httpMethod === "get" ? "IResponseWithSync" : ["post", "put", "patch", "delete"].includes(httpMethod) ? "IResponse" : "";
   methodImpl = `${descriptionText}
-  ${methodName}${methodGenerics}(${parameters}): Promise<${responseSyncType}<${responseType}>> {
+  ${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})
+${httpMethod === "get" ? `    const res = () => Validate.responseType(() => resultPromise, ${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})` : ""}
+    return SdkCache.withCache(cacheKey, res)` : ""}${["post", "put", "patch", "delete"].includes(httpMethod) ? `    return Validate.responseType(() => resultPromise, ${resolvedResponseClassValidated})` : ""}
   }
   `;
   if (!isGuardInvoked) {
     methodImpl = `${descriptionText}
       ${deprecateTag}
-  TODO_${classMethod}<T = ${resolvedResponseClass}>(${parameters}): Promise<AxiosResponse<T>> {
+  TODO_${classMethod}(${methodParams}): Promise<AxiosResponse<${resolvedResponseClass}>> {
     ${queryParamsDefault}
     const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
     return this.axiosInstance.${httpMethod}(url, ${dataPayload})
   }
     `;
   }
-  return [methodImpl, dependencies];
+  const res = {
+    methodImpl,
+    methodParams,
+    methodParamsNoTypes,
+    importStatements,
+    snippetString
+  };
+  return res;
 };
 
 class TemplateZod {
@@ -594,32 +800,32 @@ class TemplateZod {
     }
     let imports = "";
     for (const cl of Array.from(this.importClasses).sort()) {
-      imports += `  import { ${cl} } from './${cl}'
+      imports += `import { ${cl} } from './${cl}'
 `;
     }
     let exportedVariableString;
     let exportedTypeString;
     if (containsRecursiveType) {
       exportedVariableString = `
-        export const ${fileName}: z.ZodType<${fileName}> = z.lazy(() =>
+export const ${fileName}: z.ZodType<${fileName}> = z.lazy(() =>
           ${content.schemaString}
         )
       `;
       exportedTypeString = `
-        export type ${fileName} = {
+export interface ${fileName} {
           ${content.typeString}
-        }
-      `;
+}
+`;
     } else {
       exportedVariableString = `export const ${fileName} = ${content.schemaString}`;
-      exportedTypeString = `export type ${fileName} = z.TypeOf<typeof ${fileName}>`;
+      exportedTypeString = `export interface ${fileName} extends z.TypeOf<typeof ${fileName}> {}`;
     }
     const template = `import { z } from 'zod'
-  ${imports}
+${imports}
 
-  ${exportedVariableString}
+${exportedVariableString}
 
-  ${exportedTypeString}
+${exportedTypeString}
   `;
     return { buffer: template, duplicateFound: this.duplicateFound };
   };
@@ -704,7 +910,25 @@ class TemplateZod {
             typeString: refType
           };
         } else if (items) {
-          model2 = this.parseEnumItems(items);
+          if (items.type === "array") {
+            const ref3 = items.items?.$ref;
+            if (ref3) {
+              const refType = ParserUtils.parseRefType(ref3);
+              this.importClasses.add(refType);
+              model2 = {
+                schemaString: refType,
+                typeString: refType
+              };
+            } else if (items.items) {
+              model2 = this.parseEnumItems(items.items);
+            }
+            return {
+              schemaString: `${schemaAttribute} z.array(z.array(${model2.schemaString}))${schemaRequired}`,
+              typeString: `${typeAttribute} ${model2.typeString}[]${typeNullishability}`
+            };
+          } else {
+            model2 = this.parseEnumItems(items);
+          }
         } else {
           return {
             schemaString: `${schemaAttribute} z.array(z.any())${schemaRequired}`,
@@ -776,11 +1000,11 @@ class TemplateZodArray {
   render = (name) => {
     const cls = name.replace("Array", "");
     const template = `import { z } from 'zod'
-  import { ${cls} } from './${cls}'
+import { ${cls} } from './${cls}'
   
-  export const ${name} = z.array(${cls})
+export const ${name} = z.array(${cls})
 
-  export type ${name} = z.TypeOf<typeof ${name}>
+export interface ${name} extends z.TypeOf<typeof ${name}> {}
   `;
     return template;
   };
@@ -815,24 +1039,147 @@ const extractEnumObject = (type, isRequired, enumArr) => {
   };
 };
 
+const templateApiMethod = ({
+  classMethod,
+  description,
+  httpMethod,
+  path,
+  pathParams,
+  bodyParams,
+  queryParams,
+  responseClass,
+  classGenName,
+  methodParams,
+  methodParamsNoTypes
+}) => {
+  let methodSignature = "";
+  let newPath = `'${path}'`;
+  let dependencies = [];
+  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 {
+        newPath = `${newPath}.replace('{${pathParam.name}}', String(${pName}))`;
+      }
+    }
+  }
+  snippetShell = `<span class='sn-blue'>curl</span> --location --request <span class='sn-blue'>${httpMethod}</span> '<span class='sn-green'>__DOMAIN__${path}</span>' --header 'accept: application/json'`;
+  let dataType = null;
+  if (httpMethod !== "get") {
+    dataType = ParserUtils.parseBodyParamsType(bodyParams);
+    dependencies = ParserUtils.parseBodyParamsImports(bodyParams);
+    methodSignature += dataType ? `data: ${dataType},` : "";
+    bodyParams?.map((ob) => {
+      return ` <span class='sn-purple'>${ob.name}</span>`;
+    });
+    const curlParams = bodyParams?.map((ob) => {
+      return ` <span class='sn-purple'>"${ob.name}": ""</span>`;
+    });
+    snippetShell += ` --data-raw { ${curlParams}}`;
+  }
+  const isAnyRequired = ParserUtils.isAnyQueryParamRequired(queryParams);
+  queryParams.length ? `queryParams${isAnyRequired ? "" : "?"}: {${ParserUtils.parseQueryParamsType(queryParams)}}` : "";
+  queryParams.length ? `const params = {${ParserUtils.parseQueryParamsDefault(queryParams)} ...queryParams} as SDKRequestConfig` : "const params = {} as SDKRequestConfig";
+  description ? `
+  /**
+   * ${description.replace(/\n/g, "\n   * ")} 
+   */` : "";
+  const resolvedResponseClass = responseClass || "unknown";
+  const responseType = resolvedResponseClass !== "unknown" ? `${resolvedResponseClass}` : "unknown";
+  const methodImpl = `
+  async function ${classMethod}(${methodParams}): Promise<${responseType}> {
+    const $ = new ${classGenName}(Network.create(requestConfig), namespace, cache)
+    const resp = await $.${classMethod}(${methodParamsNoTypes})
+    if (resp.error) throw resp.error
+    return resp.response.data
+  }
+  `;
+  snippetSdk += `${classMethod}(${methodParams}) // return Promise<${responseType}>`;
+  return [methodImpl, dependencies, snippetSdk, snippetShell];
+};
+
+const templateApiIndex = (serviceName, serviceNameTitle, apiList) => {
+  let imports = "";
+  let returnStatement = "";
+  for (const cl of apiList) {
+    imports += `
+import { ${cl} } from './${serviceName}/${cl}'`;
+    returnStatement += `
+${cl}, `;
+  }
+  return `/**
+ * AUTO GENERATED
+ */
+${imports}
+
+const apis = {
+${returnStatement}
+}
+
+export const ${ParserUtils.convertDashesToTitleCase(serviceNameTitle)} = apis
+  `;
+};
+
+const templateSdkSnippet = (serviceNameTitle, apiName, methodSnippet) => {
+  const sdkSnippet = `
+import { Accelbyte } from '@accelbyte/sdk'
+import { ${serviceNameTitle} } from '@accelbyte/sdk-${serviceNameTitle.toLowerCase()}'
+
+const SDK_CONFIG = {
+    baseURL: 'https://demo.accelbyte.io',
+    clientId: '77f88506b6174c3ea4d925f5b4096ce8',
+    namespace: 'accelbyte',
+    redirectURI: 'http://localhost:3030'
+}
+
+const sdk = Accelbyte.SDK({
+    options: SDK_CONFIG
+})
+
+${serviceNameTitle}.${apiName}(sdk).${methodSnippet}
+`;
+  return sdkSnippet;
+};
+
 class CodeGenerator {
   static getPatchedDir = () => path__default.join(CliParser.getSwaggersOutputPath(), "patched");
   static getGeneratedPublicFolder = () => `${CliParser.getOutputPath()}/generated-public`;
   static getGeneratedAdminFolder = () => `${CliParser.getOutputPath()}/generated-admin`;
-  static iterateApi = async (api) => {
+  static getGeneratedSnippetsFolder = () => `${CliParser.getSnippetOutputPath()}/generated-snippets`;
+  static getServicePrefix = (servicePaths) => servicePaths[servicePaths.length - 1].split("/")[1];
+  static iterateApi = async (api, serviceName) => {
     const apiBufferByTag = {};
-    const jsDocApiBufferByTag = {};
+    const apiArgumentsByTag = {};
+    const classBufferByTag = {};
     const dependenciesByTag = {};
     const classImports = {};
     let arrayDefinitions = [];
-    for (const path2 in api.paths) {
+    const snippetMap = {};
+    const mapClassMethods = {};
+    const sortedPathsByLength = new Map(Object.entries(api.paths).sort((a, b) => {
+      if (a[0].length === b[0].length) {
+        return a[0].localeCompare(b[0]);
+      } else {
+        return a[0].length - b[0].length;
+      }
+    }));
+    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;
       }
-      const operation = api.paths[path2];
       const httpMethods = Object.keys(operation);
       for (const httpMethod of httpMethods) {
         const endpoint = await Endpoint.parseAsync(operation[httpMethod]).catch((error) => {
@@ -842,59 +1189,98 @@ class CodeGenerator {
         if (!endpoint.tags) {
           continue;
         }
+        if (endpoint.deprecated) {
+          continue;
+        }
         const [tag] = endpoint.tags;
-        const description = endpoint.description;
-        const isDeprecated = endpoint.deprecated;
+        mapClassMethods[tag] = mapClassMethods[tag] ? mapClassMethods[tag] : {};
+        const isForm = endpoint.consumes && endpoint.consumes[0] === "application/x-www-form-urlencoded";
+        const classMethod = ParserUtils.generateNaturalLangMethod({
+          servicePrefix,
+          path: path2,
+          httpMethod,
+          isForm,
+          existingMethods: mapClassMethods[tag]
+        });
+        mapClassMethods[tag][classMethod] = `${path2} ${httpMethod}`;
+        snippetMap[path2] = snippetMap[path2] ? snippetMap[path2] : {};
+        let description = endpoint.description;
+        description = description || "";
+        description = description.replace(/\s+/g, " ");
         const responseClass = ParserUtils.get2xxResponse(endpoint.responses);
-        const className = _.upperFirst(_.camelCase(tag));
+        const { className, classGenName } = ParserUtils.generateClassName(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, endpoint.consumes);
-          const queryParams = ParserUtils.filterQueryParameters(endpoint.parameters);
-          const pathParams = ParserUtils.filterPathParams(endpoint.parameters);
-          let bodyParams = ParserUtils.filterBodyParams(endpoint.parameters);
-          const classMethod = ParserUtils.generateClassMethod({
-            path: path2,
-            endpoint,
-            httpMethod,
-            className
-          });
-          if (endpoint.requestBody) {
-            bodyParams = [
-              {
-                name: "body",
-                in: "body",
-                schema: endpoint.requestBody.content["application/json"].schema
-              }
-            ];
-          }
-          const pathWithBase = `${api.basePath ?? ""}${path2}`;
-          const [generatedMethodString, importStatements] = templateMethod({
-            classMethod,
-            description,
-            httpMethod,
-            path: pathWithBase,
-            pathParams,
-            bodyParams,
-            queryParams,
-            isFormUrlEncoded,
-            responseClass
-          });
-          apiBufferByTag[tag] = (apiBufferByTag[tag] || "") + generatedMethodString;
-          jsDocApiBufferByTag[tag] = (jsDocApiBufferByTag[tag] || "") + templateJsdocMethod({ classMethod, httpMethod, path: path2, pathParams, bodyParams, queryParams });
-          dependenciesByTag[tag] = dependenciesByTag[tag] ? [.../* @__PURE__ */ new Set([...importStatements, ...dependenciesByTag[tag]])] : [...new Set(importStatements)];
+        if (responseClass) {
+          const importTypeClass = ParserUtils.parseRefType(responseClass);
+          classImports[className][importTypeClass] = `import { ${importTypeClass} } from '../definitions/${importTypeClass}'`;
+        }
+        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);
+        if (endpoint.requestBody) {
+          bodyParams = [
+            {
+              name: "body",
+              in: "body",
+              schema: endpoint.requestBody.content["application/json"].schema
+            }
+          ];
         }
+        const { methodImpl, methodParams, methodParamsNoTypes, importStatements, snippetString } = templateMethod({
+          classMethod,
+          description,
+          httpMethod,
+          path: pathWithBase,
+          pathParams,
+          bodyParams,
+          queryParams,
+          isFormUrlEncoded,
+          responseClass
+        });
+        classBufferByTag[tag] = (classBufferByTag[tag] || "") + methodImpl;
+        const [generatedMethodString1, importStatements1, snippetMethod, snippetShell] = templateApiMethod({
+          classMethod,
+          description,
+          httpMethod,
+          path: pathWithBase,
+          pathParams,
+          bodyParams,
+          queryParams,
+          responseClass,
+          classGenName,
+          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)];
+        const serviceNameTitle = ParserUtils.convertDashesToTitleCase(serviceName);
+        const { apiGenName } = ParserUtils.generateApiName(tag);
+        let resultSnippet = templateSdkSnippet(serviceNameTitle, apiGenName, snippetMethod);
+        resultSnippet = ParserUtils.replaceAll(resultSnippet, "<", "&lt;");
+        resultSnippet = ParserUtils.replaceAll(resultSnippet, ">", "&gt;");
+        resultSnippet = ParserUtils.replaceAll(resultSnippet, "\n", "<br/>");
+        snippetMap[path2][httpMethod] = {
+          web: resultSnippet,
+          shell: snippetShell
+        };
       }
     }
     arrayDefinitions = [...new Set(arrayDefinitions)];
-    return { apiBufferByTag, jsDocApiBufferByTag, dependenciesByTag, classImports, arrayDefinitions };
+    return {
+      apiArgumentsByTag,
+      apiBufferByTag,
+      classBufferByTag,
+      dependenciesByTag,
+      classImports,
+      arrayDefinitions,
+      snippetMap
+    };
   };
   static main = async (nameArray) => {
     const serviceName = nameArray[0];
@@ -902,7 +1288,7 @@ class CodeGenerator {
     const parser = new SwaggerParser();
     const generatedFolder = CliParser.isAdmin() ? CodeGenerator.getGeneratedAdminFolder() : CodeGenerator.getGeneratedPublicFolder();
     const DIST_DIR = `${generatedFolder}/${serviceName}`;
-    const DIST_DOCS_DIR = path__default.join(DIST_DIR, "docs");
+    const DIST_ENDPOINTS_DIR = path__default.join(DIST_DIR, "endpoints");
     const DIST_DEFINITION_DIR = path__default.join(DIST_DIR, "definitions");
     const swaggerFilePath = `${CliParser.getSwaggersOutputPath()}/${swaggerFile}`;
     const swaggerPatchedFilePath = `${CodeGenerator.getPatchedDir()}/${swaggerFile}`;
@@ -910,20 +1296,35 @@ class CodeGenerator {
     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);
+    console.log("----------\nGenerating API:", { title: api.info.title, version: api.info.version });
     ParserUtils.mkdirIfNotExist(DIST_DIR);
-    ParserUtils.mkdirIfNotExist(DIST_DOCS_DIR);
     ParserUtils.mkdirIfNotExist(DIST_DEFINITION_DIR);
-    const { apiBufferByTag, dependenciesByTag, classImports, arrayDefinitions } = await CodeGenerator.iterateApi(api);
+    ParserUtils.mkdirIfNotExist(DIST_ENDPOINTS_DIR);
+    ParserUtils.syncPackageVersion(api.info, CliParser.isAdmin());
+    const { apiArgumentsByTag, apiBufferByTag, classBufferByTag, dependenciesByTag, classImports, arrayDefinitions, snippetMap } = await CodeGenerator.iterateApi(api, serviceName);
+    if (CliParser.getSnippetOutputPath()) {
+      ParserUtils.writeSnippetFile(CodeGenerator.getGeneratedSnippetsFolder(), api.info.title, JSON.stringify(snippetMap, null, 2));
+    }
     const targetSrcFolder = `${CliParser.getOutputPath()}/`;
-    for (const tag in apiBufferByTag) {
-      const className = _.upperFirst(_.camelCase(tag));
-      const apiBuffer = apiBufferByTag[tag];
+    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 classGenName = CliParser.isAdmin() ? className + "Admin$" : className + "$";
-      ParserUtils.writeClassFile(DIST_DIR, classGenName, apiBuffer, imports);
-      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default.join(DIST_DIR, `${classGenName}`), targetSrcFolder));
+      const apiImports = [.../* @__PURE__ */ new Set([...dependenciesByTag[tag], ...Object.values(classImports[className])])];
+      apiImports.push(`import { ${classGenName} } from './endpoints/${classGenName}'`);
+      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]);
+      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));
     }
+    const serviceNameTitle = ParserUtils.convertDashesToTitleCase(serviceName);
+    const apiIndexBuff = templateApiIndex(serviceName, serviceNameTitle, apiList);
+    ParserUtils.writeApiMainFile(generatedFolder, serviceNameTitle, apiIndexBuff);
+    indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default.join(generatedFolder, serviceNameTitle), targetSrcFolder));
     const duplicates = /* @__PURE__ */ new Map();
     const definitions = api?.components?.schemas || api.definitions;
     for (const ref in definitions) {
@@ -952,7 +1353,7 @@ class CodeGenerator {
       ParserUtils.writeDefinitionFile(DIST_DEFINITION_DIR, arrayClass, buffer);
       indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default.join(DIST_DEFINITION_DIR, arrayClass), targetSrcFolder));
     }
-    console.log("\n----------\nCOMPLETED.\n----------\n\n");
+    console.log("\nCOMPLETED\n----------\n\n");
     return indexImportsSet;
   };
 }
@@ -979,7 +1380,7 @@ class SwaggerDownloader {
       });
     });
     request.on("error", (err) => {
-      console.log(`SwaggerDownloader dl failed for "${targetFileName}" and "${url}"`, err);
+      console.log(`SwaggerDownloader failed for "${targetFileName}" and "${url}"`, err);
     });
   };
   static main = () => {