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

package/dist/accelbyte-codegen.js

@@ -7,8 +7,8 @@ var zod = require('zod');
 var fs = require('fs');
 var path = require('path');
 var SwaggerParser = require('@apidevtools/swagger-parser');
-var _ = require('lodash');
 var fastJsonPatch = require('fast-json-patch');
+var _ = require('lodash');
 var https = require('https');
 
 function _interopNamespaceDefault(e) {
@@ -101,15 +101,15 @@ const generateImports = (body, importStatements) => {
 ${importStatements.sort().join("\n")}`;
 };
 const templateClass = (className, body, importStatements) => `/**
-   * DON'T EDIT THIS FILE, it is AUTO GENERATED
-   */
-  ${generateImports(body, importStatements)}
+ * DON'T EDIT THIS FILE, it is AUTO GENERATED
+ */
+${generateImports(body, importStatements)}
 
-  export class ${className} {
-      // @ts-ignore
-      constructor(private axiosInstance: AxiosInstance, private namespace: string, private cache = false) {}
+export class ${className} {
+  // @ts-ignore
+  constructor(private axiosInstance: AxiosInstance, private namespace: string, private cache = false) {}
   ${body}
-  }
+}
   `;
 
 const templateJsdocFile = (apiName, body) => `
@@ -120,7 +120,13 @@ ${body}
 \`\`\`
 `.replace(/, \)/g, ")").trim();
 
+const SERVICE_PREFIXES = ["/iam/", "/gdpr/", "/sessionbrowser/", "/event/", "/admin/", "/public/"];
 class ParserUtils {
+  static generateClassName = (tag) => {
+    const className = _.upperFirst(_.camelCase(tag));
+    const classGenName = CliParser.isAdmin() ? className + "Admin$" : className + "$";
+    return { className, classGenName };
+  };
   static parseQueryParamAttributeDefault = (definition) => {
     const attrName = definition.name.slice(definition.name.lastIndexOf(".") + 1);
     const defaultValue = definition.type === "string" ? `'${definition.default}'` : definition.default;
@@ -261,6 +267,54 @@ class ParserUtils {
     }
     return parameters.filter((parameter) => parameter.in === "path");
   }
+  static mappedMethod = (httpMethod, isForm) => {
+    if (httpMethod === "get") {
+      return "fetch";
+    } 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";
+    }
+  };
+  static generateHumanReadableMethod({ path: path2, httpMethod, isForm }) {
+    let path_ = path2.replace();
+    SERVICE_PREFIXES.forEach((prefix) => {
+      path_ = path_.replace(prefix, "/");
+    });
+    path_ = path_.substring(1);
+    const arrLastWords = path_.split("}/");
+    let lastWords = arrLastWords[arrLastWords.length - 1];
+    lastWords = lastWords.split("/{")[0];
+    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 = "By" + _.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.join("/");
+    let res = _.camelCase(ParserUtils.mappedMethod(httpMethod, isForm) + genPath);
+    res = res.replace("ByNamespace", "");
+    return res;
+  }
   static generateClassMethod({
     path: path2,
     endpoint,
@@ -279,8 +333,8 @@ class ParserUtils {
     }
     let classMethod = httpMethod + "/" + replacedIdsPath;
     classMethod = _.camelCase(classMethod);
-    classMethod = classMethod.replace("PublicNamespacesByNamespace", "");
-    classMethod = classMethod.replace("AdminNamespacesByNamespace", "Admin");
+    classMethod = classMethod.replace("PublicNamespacesByNamespace", "Ns");
+    classMethod = classMethod.replace("AdminNamespacesByNamespace", "AdminNs");
     const searchWord = "NamespacesByNamespace";
     const nsExistInsideMethod = classMethod.indexOf(searchWord) > 0 && classMethod.indexOf(searchWord) + searchWord.length < classMethod.length;
     const excludedClasses = ["Policies"];
@@ -314,6 +368,9 @@ class ParserUtils {
     const jsdocFile = templateJsdocFile(nameArray[0], apiBuffer);
     fs.writeFileSync(`${distDir}/docs/${nameArray[0]}.md`, jsdocFile);
   }
+  static writeSnippetFile(distDir, name, docBuffer) {
+    fs.writeFileSync(`${distDir}/${name}.json`, docBuffer);
+  }
   static writeDefinitionFile(distDir, name, buffer) {
     ParserUtils.mkdirIfNotExist(distDir);
     fs.writeFileSync(path.join(distDir, `${name}.ts`), ParserUtils.prependCopyrightHeader(buffer));
@@ -322,6 +379,16 @@ 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 toCamelCase(str) {
     return str.split("/").map(function(word, index) {
       if (index === 0) {
@@ -355,6 +422,29 @@ class ParserUtils {
     }
     const swaggerContent = JSON.parse(fs.readFileSync(swaggerFilePath, "utf8"));
     const swaggerPatchFileContent = JSON.parse(fs.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 } = fastJsonPatch.applyPatch(swaggerContent, swaggerPatchFileContent);
     fs.writeFileSync(swaggerPatchedFilePath, JSON.stringify(newDocument, null, 2));
   }
@@ -463,50 +553,6 @@ zod.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,
@@ -521,6 +567,9 @@ const templateMethod = ({
   let methodSignature = "";
   let newPath = `'${path}'`;
   let dependencies = [];
+  let snippetString = "";
+  let snippetMethodSignature = "";
+  let snippetCurl = "";
   for (const pathParam of pathParams) {
     const type = ParserUtils.parseType(pathParam);
     if (pathParam.name !== "namespace") {
@@ -535,11 +584,20 @@ 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}}`;
   }
   const isAnyRequired = ParserUtils.isAnyQueryParamRequired(queryParams);
   const queryParamsType = queryParams.length ? `queryParams${isAnyRequired ? "" : "?"}: {${ParserUtils.parseQueryParamsType(queryParams)}}` : "";
@@ -575,20 +633,23 @@ const templateMethod = ({
   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 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) {
@@ -601,7 +662,7 @@ ${httpMethod === "get" ? `const res = () => Validate.responseType(() => resultPr
   }
     `;
   }
-  return [methodImpl, dependencies];
+  return [methodImpl, dependencies, snippetString, snippetCurl];
 };
 
 class TemplateZod {
@@ -617,32 +678,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 };
   };
@@ -799,11 +860,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;
   };
@@ -838,16 +899,18 @@ const extractEnumObject = (type, isRequired, enumArr) => {
   };
 };
 
+const BUILD_DATE = new Date().toISOString();
 class CodeGenerator {
   static getPatchedDir = () => path.join(CliParser.getSwaggersOutputPath(), "patched");
   static getGeneratedPublicFolder = () => `${CliParser.getOutputPath()}/generated-public`;
   static getGeneratedAdminFolder = () => `${CliParser.getOutputPath()}/generated-admin`;
+  static getGeneratedSnippetsFolder = () => `${CliParser.getOutputPath()}/../../../../apps/api-explorer-app/src/generated-snippets`;
   static iterateApi = async (api) => {
     const apiBufferByTag = {};
-    const jsDocApiBufferByTag = {};
     const dependenciesByTag = {};
     const classImports = {};
     let arrayDefinitions = [];
+    const snippetMap = {};
     for (const path2 in api.paths) {
       const isAdminEndpoint = path2.indexOf("/admin/") > -1;
       if (CliParser.isAdmin() && !isAdminEndpoint) {
@@ -869,9 +932,10 @@ class CodeGenerator {
         const description = endpoint.description;
         const isDeprecated = endpoint.deprecated;
         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) {
+          snippetMap[path2] = snippetMap[path2] ? snippetMap[path2] : {};
           if (responseClass) {
             const importTypeClass = ParserUtils.parseRefType(responseClass);
             classImports[className][importTypeClass] = `import { ${importTypeClass} } from './definitions/${importTypeClass}'`;
@@ -883,12 +947,8 @@ class CodeGenerator {
           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
-          });
+          const isForm = endpoint.consumes && endpoint.consumes[0] === "application/x-www-form-urlencoded";
+          const classMethod = ParserUtils.generateHumanReadableMethod({ path: path2, httpMethod, isForm });
           if (endpoint.requestBody) {
             bodyParams = [
               {
@@ -899,7 +959,7 @@ class CodeGenerator {
             ];
           }
           const pathWithBase = `${api.basePath ?? ""}${path2}`;
-          const [generatedMethodString, importStatements] = templateMethod({
+          const [generatedMethodString, importStatements, snippetString, snippetCurl] = templateMethod({
             classMethod,
             description,
             httpMethod,
@@ -911,13 +971,16 @@ class CodeGenerator {
             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)];
+          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
+          };
         }
       }
     }
     arrayDefinitions = [...new Set(arrayDefinitions)];
-    return { apiBufferByTag, jsDocApiBufferByTag, dependenciesByTag, classImports, arrayDefinitions };
+    return { apiBufferByTag, dependenciesByTag, classImports, arrayDefinitions, snippetMap };
   };
   static main = async (nameArray) => {
     const serviceName = nameArray[0];
@@ -937,13 +1000,16 @@ class CodeGenerator {
     ParserUtils.mkdirIfNotExist(DIST_DIR);
     ParserUtils.mkdirIfNotExist(DIST_DOCS_DIR);
     ParserUtils.mkdirIfNotExist(DIST_DEFINITION_DIR);
-    const { apiBufferByTag, dependenciesByTag, classImports, arrayDefinitions } = await CodeGenerator.iterateApi(api);
+    ParserUtils.writeVersionFile(DIST_DIR, "Version.ts", serviceName, api.info, BUILD_DATE);
+    const { apiBufferByTag, dependenciesByTag, classImports, arrayDefinitions, snippetMap } = await CodeGenerator.iterateApi(api);
+    if (!CliParser.isAdmin()) {
+      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 { className, classGenName } = ParserUtils.generateClassName(tag);
       const apiBuffer = apiBufferByTag[tag];
       const imports = [.../* @__PURE__ */ new Set([...dependenciesByTag[tag], ...Object.values(classImports[className])])];
-      const classGenName = CliParser.isAdmin() ? className + "Admin$" : className + "$";
       ParserUtils.writeClassFile(DIST_DIR, classGenName, apiBuffer, imports);
       indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(DIST_DIR, `${classGenName}`), targetSrcFolder));
     }