@accelbyte/codegen 1.0.0-beta.6 → 1.0.1-experimental.1

package/dist/accelbyte-codegen.js

@@ -79,18 +79,18 @@ class CliParser {
   };
 }
 
-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 = (body, importStatements) => {
-  const usedImportVarMap = makeNewImportVarMap();
-  const importableVarMap = getImportableVarMap();
+const generateImports = (body, importStatements, makeNewImportVarMap2, getImportableVarMap2) => {
+  const usedImportVarMap = makeNewImportVarMap2;
+  const importableVarMap = getImportableVarMap2;
   for (const [moduleSource, importableVars] of Object.entries(importableVarMap)) {
     for (const importableVar of importableVars) {
       const importVarRegex = new RegExp(`(?<![\\d\\w_])${importableVar}(?![\\d\\w_])`);
@@ -103,10 +103,11 @@ const generateImports = (body, importStatements) => {
   return `${generatedImports}
 ${importStatements.sort().join("\n")}`;
 };
-const templateClass = (className, body, importStatements) => `/**
- * DON'T EDIT THIS FILE, it is AUTO GENERATED
+const templateClass = (className, body, importStatements) => {
+  return `/**
+ * AUTO GENERATED
  */
-${generateImports(body, importStatements)}
+${generateImports(body, importStatements, makeNewImportVarMap$1(), getImportableVarMap$1())}
 
 export class ${className} {
   // @ts-ignore
@@ -114,15 +115,37 @@ export class ${className} {
   ${body}
 }
   `;
+};
 
-const templateJsdocFile = (apiName, body) => `
-\`\`\`
-SDK.getService('${apiName}', authHeader):
-${body}
+const getImportableVarMap = () => ({
+  "@accelbyte/sdk": ["CodeGenUtil", "SdkCache", "IResponse", "IResponseWithSync", "Validate", "ApiArgs", "Network", "AccelbyteSDK"]
+});
+const makeNewImportVarMap = () => ({
+  "@accelbyte/sdk": ["AccelbyteSDK", "ApiArgs", "ApiUtils"]
+});
+const templateApiClass = (className, body, importStatements, returnMethods) => {
+  return `/**
+ * AUTO GENERATED
+ */
+/* eslint-disable camelcase */
+${generateImports(body, importStatements, makeNewImportVarMap(), getImportableVarMap())}
 
-\`\`\`
-`.replace(/, \)/g, ")").trim();
+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 UNDEFINED_SWAGGER_SEMVER = "0.0.0";
 const REMOVED_KEYWORDS = [
   "/admin/",
   "/public/",
@@ -136,39 +159,62 @@ const REMOVED_KEYWORDS = [
   "/{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;
     return `${attrName}: ${defaultValue}`;
   };
   static parseType = (pathParam) => {
-    if (pathParam.type === "int" || pathParam.type === "integer" || pathParam?.schema?.type === "integer")
+    if (isSwaggerIntegerType(pathParam.type || pathParam?.schema?.type))
       return "number";
-    if (pathParam.type === "array")
+    if (pathParam.type === "array") {
+      if (isSwaggerIntegerType(pathParam.items.type))
+        return "number[]";
       return `${pathParam.items.type ?? "any"}[]`;
-    if (pathParam?.schema?.type === "array")
+    }
+    if (pathParam?.schema?.type === "array") {
+      if (isSwaggerIntegerType(pathParam.schema.items.type))
+        return "number[]";
       return `${pathParam.schema.items.type ?? "any"}[]`;
+    }
     if (pathParam?.schema?.type)
       return pathParam.schema.type;
     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(".", "/");
@@ -187,7 +233,7 @@ class ParserUtils {
       return null;
     }
     const type = ParserUtils.parseRefType($ref);
-    return `import { ${type} } from './definitions/${type}'`;
+    return `import { ${type} } from '../definitions/${type}.js'`;
   };
   static parseRefType = ($ref) => {
     let ref = $ref.replace(".", "/");
@@ -234,6 +280,8 @@ class ParserUtils {
       return retBodyParams;
     }
     if (bodyParam?.schema?.type === "array" && !bodyParam?.schema?.items?.$ref) {
+      if (isSwaggerIntegerType(bodyParam.schema.items.type))
+        return "number[]";
       return `${bodyParam.schema.items.type ?? "any"}[]`;
     }
     if (bodyParam?.schema?.type === "array" && bodyParam?.schema?.items?.$ref) {
@@ -290,8 +338,8 @@ class ParserUtils {
     path_ = path_.substring(1);
     const isPlural = httpMethod === "get" && !(path2.slice(-1) === "}");
     if (!isPlural) {
-      path_ = replaceAll(path_, "ies/", "y/");
-      path_ = replaceAll(path_, "s/", "/");
+      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$/, "");
@@ -330,7 +378,7 @@ class ParserUtils {
     });
     const genPath = _.upperFirst(lastWords) + "/" + listBeforeLastWords.join("/") + listByParams.reverse().join("/");
     let generatedMethod = _.camelCase(mappedMethod(httpMethod, isForm) + genPath);
-    generatedMethod = replaceAll(generatedMethod, "Byword", "_By");
+    generatedMethod = ParserUtils.replaceAll(generatedMethod, "Byword", "_By");
     generatedMethod = resolveConflicts(path2, generatedMethod, existingMethods);
     return generatedMethod;
   };
@@ -355,12 +403,22 @@ class ParserUtils {
     const fileContent = templateClass(apiName, apiBuffer, imports);
     fs.writeFileSync(`${distDir}/${apiName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
   }
-  static writeJsdocFile(distDir, nameArray, apiBuffer) {
-    const jsdocFile = templateJsdocFile(nameArray[0], apiBuffer);
-    fs.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.writeFileSync(`${distDir}/${apiName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
+  }
+  static writeApiMainFile(distDir, serviceName, fileContent) {
+    fs.writeFileSync(`${distDir}/${serviceName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
   }
   static writeSnippetFile(distDir, name, docBuffer) {
-    fs.writeFileSync(`${distDir}/${name}.json`, docBuffer);
+    let snippetFileName = ParserUtils.replaceAll(name, " ", "-").toLowerCase();
+    snippetFileName = snippetFileName.replace("justice-", "");
+    snippetFileName = "snippet-" + snippetFileName + ".json";
+    fs.writeFileSync(`${distDir}/${snippetFileName}`, docBuffer);
   }
   static writeDefinitionFile(distDir, name, buffer) {
     ParserUtils.mkdirIfNotExist(distDir);
@@ -370,15 +428,36 @@ class ParserUtils {
     ParserUtils.mkdirIfNotExist(distDir);
     fs.writeFileSync(path.join(distDir, `all-${isAdminWebSdk ? "admin" : "public"}-imports.ts`), ParserUtils.prependCopyrightHeader(buffer));
   }
-  static writeVersionFile(distDir, fileName, serviceName, apiInfo, buildDate) {
-    const ver = apiInfo.version ? `'${apiInfo.version}'` : void 0;
-    fs.writeFileSync(`${distDir}/${fileName}`, `export default {
-  title: '${serviceName}',
-  name: '${apiInfo.title}',
-  version: ${ver},
-  buildDate: '${buildDate}'
-}
-`);
+  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) {
+    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];
+    fs.writeFileSync(pathToPackageJSON, JSON.stringify(packageJSON, null, 2));
+    ParserUtils.syncChangelog(packageJSON.version);
+  }
+  static getPackageJSONInfo(dir) {
+    const pathToPackageJSON = path.join(dir, "./package.json");
+    return { packageJSON: JSON.parse(fs.readFileSync(pathToPackageJSON, "utf-8")), pathToPackageJSON };
   }
   static toCamelCase(str) {
     return str.split("/").map(function(word, index) {
@@ -453,12 +532,9 @@ class ParserUtils {
 ${content}`;
   };
 }
-const replaceAll = (string, search, replace) => {
-  return string.split(search).join(replace);
-};
 const mappedMethod = (httpMethod, isForm) => {
   if (httpMethod === "get") {
-    return "fetch";
+    return "get";
   } else if (httpMethod === "post" && isForm) {
     return "post";
   } else if (httpMethod === "post") {
@@ -517,6 +593,9 @@ const testConflict = (path2, generatedMethod, existingMethods) => {
  existingMethods: ${JSON.stringify(existingMethods, null, 2)}`);
   }
 };
+const isSwaggerIntegerType = (type) => {
+  return type === "integer" || type === "int";
+};
 
 const Schema = zod.z.object({
   $ref: zod.z.string().nullish(),
@@ -619,16 +698,15 @@ const templateMethod = ({
   isFormUrlEncoded,
   responseClass
 }) => {
-  let methodSignature = "";
+  let methodParams = "";
+  let methodParamsNoTypes = "";
   let newPath = `'${path}'`;
-  let dependencies = [];
-  let snippetString = "";
-  let snippetMethodSignature = "";
-  let snippetCurl = "";
+  let importStatements = [];
   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}}`)) {
@@ -639,20 +717,12 @@ const templateMethod = ({
       }
     }
   }
-  snippetCurl = `<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},` : "";
-    const snippetParams = bodyParams?.map((ob) => {
-      return ` <span class='sn-purple'>${ob.name}</span>`;
-    });
-    snippetMethodSignature += snippetParams ? `data: { ${snippetParams} }` : "";
-    const curlParams = bodyParams?.map((ob) => {
-      return ` <span class='sn-purple'>"${ob.name}": ""</span>`;
-    });
-    snippetCurl += ` --data-raw { ${curlParams}}`;
+    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)}}` : "";
@@ -662,7 +732,7 @@ const templateMethod = ({
   let dataPayload = "{params}";
   const descriptionText = description ? `
   /**
-   * ${(description || "").replace(/\n/g, "\n   * ")} 
+   * ${description.replace(/\n/g, "\n   * ")} 
    */` : "";
   let formPayloadString = "";
   if (isFormUrlEncoded) {
@@ -674,23 +744,21 @@ 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 generateMethodName = () => `${methodName}${methodGenerics}(${parameters}): Promise<${responseSyncType}<${responseType}>>`;
-  const generateSnippetMethodName = () => `${methodName}(${snippetMethodSignature})`;
-  snippetString += `${generateSnippetMethodName()}`;
+  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()} {
@@ -698,26 +766,32 @@ const templateMethod = ({
     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}, '${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}, '${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, snippetString, snippetCurl];
+  const res = {
+    methodImpl,
+    methodParams,
+    methodParamsNoTypes,
+    importStatements
+  };
+  return res;
 };
 
 class TemplateZod {
@@ -733,7 +807,7 @@ class TemplateZod {
     }
     let imports = "";
     for (const cl of Array.from(this.importClasses).sort()) {
-      imports += `import { ${cl} } from './${cl}'
+      imports += `import { ${cl} } from './${cl}.js'
 `;
     }
     let exportedVariableString;
@@ -843,7 +917,25 @@ ${exportedTypeString}
             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}`,
@@ -915,7 +1007,7 @@ class TemplateZodArray {
   render = (name) => {
     const cls = name.replace("Array", "");
     const template = `import { z } from 'zod'
-import { ${cls} } from './${cls}'
+import { ${cls} } from './${cls}.js'
   
 export const ${name} = z.array(${cls})
 
@@ -954,15 +1046,138 @@ const extractEnumObject = (type, isRequired, enumArr) => {
   };
 };
 
-const BUILD_DATE = new Date().toISOString();
+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 {
+        newPath = `${newPath}.replace('{${pathParam.name}}', String(${pName}))`;
+      }
+    }
+  }
+  snippetShell = `curl --location --request  \\
+    ${httpMethod} '__DOMAIN__${path}'  \\
+    --header 'accept: application/json'`;
+  if (httpMethod !== "get") {
+    const curlParams = bodyParams?.map((ob) => {
+      return ` "${ob.name}": ""`;
+    });
+    snippetShell += `  \\
+    --data-raw '{ ${curlParams}}'`;
+  }
+  const descriptionText = description ? `
+  /**
+   * ${description.replace(/\n/g, "\n   * ")} 
+   */` : "";
+  const resolvedResponseClass = responseClass || "unknown";
+  const responseType = resolvedResponseClass !== "unknown" ? `${resolvedResponseClass}` : "unknown";
+  const methodImpl = `
+  ${descriptionText}
+  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
+  }
+  `;
+  const snippetPromiseString = responseType !== "unknown" ? `Promise<${responseType}>` : "Promise";
+  snippetSdk += `${classMethod}(${methodParams}) 
+   // return ${snippetPromiseString}`;
+  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:");
+  normMethod = normalizeMethodSnippet(normMethod, "queryParams:");
+  normMethod = normalizeMethodSnippet(normMethod, "queryParams?:");
+  normMethod += "\n\n//" + methodArr[1];
+  const sdkSnippet = `import { Accelbyte } from '@accelbyte/sdk'
+import { ${serviceNameTitle} } from '@accelbyte/sdk-${serviceNameTitle.toLowerCase()}'
+
+const sdk = Accelbyte.SDK({
+    baseURL: 'https://demo.accelbyte.io',
+    clientId: '77f88506b6174c3ea4d925f5b4096ce8',
+    namespace: 'accelbyte',
+    redirectURI: 'http://localhost:3030'
+})
+
+${serviceNameTitle}.${apiName}(sdk)
+     .${normMethod}`;
+  return sdkSnippet;
+};
+const normalizeMethodSnippet = (methodInput, splitWord) => {
+  const split1 = methodInput.split(splitWord);
+  if (!split1[1]) {
+    return methodInput;
+  }
+  let split2 = split1[1].trim();
+  split2 = ParserUtils.replaceAll(split2, "{", "");
+  split2 = ParserUtils.replaceAll(split2, "})", "");
+  split2 = split2.split(",");
+  let params = "";
+  split2.forEach((p) => {
+    params += "\n             " + ParserUtils.replaceAll(p.trim(), ")", "") + ",";
+  });
+  params = params.slice(0, -1);
+  const result = split1[0] + splitWord + " {" + params + "\n    })";
+  return result;
+};
+
+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`;
   static getServicePrefix = (servicePaths) => servicePaths[servicePaths.length - 1].split("/")[1];
-  static iterateApi = async (api) => {
+  static iterateApi = async (api, serviceName) => {
     const apiBufferByTag = {};
+    const apiArgumentsByTag = {};
+    const classBufferByTag = {};
     const dependenciesByTag = {};
     const classImports = {};
     let arrayDefinitions = [];
@@ -977,7 +1192,6 @@ class CodeGenerator {
     }));
     const sortedKeys = Array.from(sortedPathsByLength.keys());
     const servicePrefix = CodeGenerator.getServicePrefix(sortedKeys);
-    console.log("ServicePrefix", servicePrefix, ", Paths:", sortedKeys);
     for (const [path2, operation] of sortedPathsByLength) {
       const isAdminEndpoint = path2.indexOf("/admin/") > -1;
       if (CliParser.isAdmin() && !isAdminEndpoint) {
@@ -1009,13 +1223,15 @@ class CodeGenerator {
         });
         mapClassMethods[tag][classMethod] = `${path2} ${httpMethod}`;
         snippetMap[path2] = snippetMap[path2] ? snippetMap[path2] : {};
-        const description = endpoint.description;
+        let description = endpoint.description;
+        description = description || "";
+        description = description.replace(/\s+/g, " ");
         const responseClass = ParserUtils.get2xxResponse(endpoint.responses);
         const { className, classGenName } = ParserUtils.generateClassName(tag);
         classImports[className] = classImports[className] ? classImports[className] : {};
         if (responseClass) {
           const importTypeClass = ParserUtils.parseRefType(responseClass);
-          classImports[className][importTypeClass] = `import { ${importTypeClass} } from './definitions/${importTypeClass}'`;
+          classImports[className][importTypeClass] = `import { ${importTypeClass} } from '../definitions/${importTypeClass}.js'`;
         }
         if (responseClass && responseClass.endsWith("Array")) {
           arrayDefinitions.push(responseClass);
@@ -1034,7 +1250,7 @@ class CodeGenerator {
             }
           ];
         }
-        const [generatedMethodString, importStatements, snippetString, snippetCurl] = templateMethod({
+        const { methodImpl, methodParams, methodParamsNoTypes, importStatements } = templateMethod({
           classMethod,
           description,
           httpMethod,
@@ -1045,16 +1261,42 @@ class CodeGenerator {
           isFormUrlEncoded,
           responseClass
         });
-        apiBufferByTag[tag] = (apiBufferByTag[tag] || "") + generatedMethodString;
+        classBufferByTag[tag] = (classBufferByTag[tag] || "") + methodImpl;
+        const [generatedMethodString1, snippetMethod, snippetShell] = templateApiMethod({
+          classMethod,
+          description,
+          httpMethod,
+          path: pathWithBase,
+          pathParams,
+          bodyParams,
+          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);
+        const resultSnippet = templateSdkSnippet(serviceNameTitle, apiGenName, snippetMethod);
         snippetMap[path2][httpMethod] = {
-          web: `<span class='sn-blue'>import</span> axios from 'axios'<br/><span class='sn-blue'>import</span> { <span class='sn-purple'>${classGenName}</span> } <span class='sn-blue'>from</span> <span class='sn-green'>'@accelbyte/sdk'</span><br/><br/><span class='sn-blue'>const</span> axios = <span class='sn-blue'>axios</span>.create({<span class='sn-purple'>clientId</span>, <span class='sn-purple'>redirectURI</span>, <span class='sn-purple'>baseURL</span>})<br/><br/><span class='sn-blue'>new</span> ${classGenName}(<span class='sn-purple'>axios</span>, <span class='sn-purple'>namespace</span>).<span class='method-name'>${snippetString}</span>`,
-          shell: snippetCurl
+          web: resultSnippet,
+          webGit: GIT_URL + `/sdk-${serviceName}/src/generated-public/${serviceName}/${apiGenName}.ts`,
+          shell: snippetShell
         };
       }
     }
     arrayDefinitions = [...new Set(arrayDefinitions)];
-    return { apiBufferByTag, dependenciesByTag, classImports, arrayDefinitions, snippetMap };
+    return {
+      apiArgumentsByTag,
+      apiBufferByTag,
+      classBufferByTag,
+      dependenciesByTag,
+      classImports,
+      arrayDefinitions,
+      snippetMap
+    };
   };
   static main = async (nameArray) => {
     const serviceName = nameArray[0];
@@ -1062,6 +1304,7 @@ class CodeGenerator {
     const parser = new SwaggerParser();
     const generatedFolder = CliParser.isAdmin() ? CodeGenerator.getGeneratedAdminFolder() : CodeGenerator.getGeneratedPublicFolder();
     const DIST_DIR = `${generatedFolder}/${serviceName}`;
+    const DIST_ENDPOINTS_DIR = path.join(DIST_DIR, "endpoints");
     const DIST_DEFINITION_DIR = path.join(DIST_DIR, "definitions");
     const swaggerFilePath = `${CliParser.getSwaggersOutputPath()}/${swaggerFile}`;
     const swaggerPatchedFilePath = `${CodeGenerator.getPatchedDir()}/${swaggerFile}`;
@@ -1072,19 +1315,32 @@ class CodeGenerator {
     console.log("----------\nGenerating API:", { title: api.info.title, version: api.info.version });
     ParserUtils.mkdirIfNotExist(DIST_DIR);
     ParserUtils.mkdirIfNotExist(DIST_DEFINITION_DIR);
-    ParserUtils.writeVersionFile(DIST_DIR, "Version.ts", serviceName, api.info, BUILD_DATE);
-    const { apiBufferByTag, dependenciesByTag, classImports, arrayDefinitions, snippetMap } = 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 apiList = [];
+    for (const tag in classBufferByTag) {
       const { className, classGenName } = ParserUtils.generateClassName(tag);
-      const apiBuffer = apiBufferByTag[tag];
+      const classBuffer = classBufferByTag[tag];
       const imports = [.../* @__PURE__ */ new Set([...dependenciesByTag[tag], ...Object.values(classImports[className])])];
-      ParserUtils.writeClassFile(DIST_DIR, classGenName, apiBuffer, imports);
-      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(DIST_DIR, `${classGenName}`), targetSrcFolder));
+      const apiImports = [.../* @__PURE__ */ new Set([...dependenciesByTag[tag], ...Object.values(classImports[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]);
+      apiList.push(apiGenName);
+      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(DIST_ENDPOINTS_DIR, `${classGenName}`), targetSrcFolder));
+      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.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.join(generatedFolder, serviceNameTitle), targetSrcFolder));
     const duplicates = /* @__PURE__ */ new Map();
     const definitions = api?.components?.schemas || api.definitions;
     for (const ref in definitions) {
@@ -1129,6 +1385,22 @@ class SwaggerDownloader {
     fs__namespace.writeFileSync(destFile, "");
     return destFile;
   };
+  static postSanitizeDownloadedFile = (filePath) => {
+    const searchStr = ["%5B", "%5D", "%20", "%7B", "%7D"];
+    fs__namespace.readFile(filePath, "utf8", (err, data) => {
+      if (err)
+        throw err;
+      let result = data;
+      searchStr.forEach((s) => {
+        result = result.replace(new RegExp(s, "g"), " ");
+      });
+      fs__namespace.writeFile(filePath, result, "utf8", (err2) => {
+        if (err2)
+          throw err2;
+        console.log("File updated successfully.");
+      });
+    });
+  };
   static downloadFile = (targetFileName, url) => {
     const destFile = SwaggerDownloader.getDestFile(targetFileName);
     const file = fs__namespace.createWriteStream(destFile);
@@ -1136,6 +1408,7 @@ class SwaggerDownloader {
       response.pipe(file);
       file.on("finish", () => {
         file.close();
+        SwaggerDownloader.postSanitizeDownloadedFile(destFile);
         console.log(`SwaggerDownload ${url} completed`);
       });
     });