@accelbyte/codegen 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/accelbyte-codegen.js

@@ -127,10 +127,14 @@ class ParserUtils {
     return `${attrName}: ${defaultValue}`;
   };
   static parseType = (pathParam) => {
-    if (pathParam.type === "int" || pathParam.type === "integer")
+    if (pathParam.type === "int" || pathParam.type === "integer" || pathParam?.schema?.type === "integer")
       return "number";
     if (pathParam.type === "array")
       return `${pathParam.items.type ?? "any"}[]`;
+    if (pathParam?.schema?.type === "array")
+      return `${pathParam.schema.items.type ?? "any"}[]`;
+    if (pathParam?.schema?.type)
+      return pathParam.schema.type;
     return pathParam.type;
   };
   static parseQueryParamsType = (queryParams) => {
@@ -183,7 +187,7 @@ class ParserUtils {
     if (definition.type && ParserUtils.parseType(definition) === "number") {
       return `${attrName}${required}: number`;
     }
-    if (definition?.schema?.type && ParserUtils.parseType(definition.schema) === "number") {
+    if (definition?.schema?.type && ParserUtils.parseType(definition) === "number") {
       return `${attrName}${required}: number`;
     }
     if (definition.type && definition.type === "array") {
@@ -275,8 +279,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"];
@@ -376,7 +380,7 @@ const Schema = zod.z.object({
     $ref: zod.z.string().nullish(),
     type: zod.z.string().nullish()
   }).nullish(),
-  properties: zod.z.array(zod.z.string()).nullish(),
+  properties: zod.z.union([zod.z.array(zod.z.string()).nullish(), zod.z.record(zod.z.object({ type: zod.z.string() })).nullish()]),
   description: zod.z.string().nullish(),
   additionalProperties: zod.z.object({
     type: zod.z.string().nullish()
@@ -421,7 +425,15 @@ const Endpoint = zod.z.object({
       })
     }).nullish()
   })),
-  parameters: zod.z.array(EndpointParameters).nullish()
+  parameters: zod.z.array(EndpointParameters).nullish(),
+  requestBody: zod.z.object({
+    required: zod.z.boolean(),
+    content: zod.z.object({
+      "application/json": zod.z.object({
+        schema: Schema.nullish()
+      })
+    }).nullish()
+  }).nullish()
 });
 const Operation = zod.z.object({
   get: Endpoint.nullish(),
@@ -638,13 +650,17 @@ class TemplateZod {
     if (definition.additionalProperties) {
       return this.parseToZodAttribute("", definition, []);
     }
-    if (!definition.properties) {
+    let properties;
+    if (definition.properties) {
+      properties = Object.entries(definition.properties);
+    } else if (definition.items?.properties) {
+      properties = Object.entries(definition.items.properties);
+    } else {
       return {
         schemaString: "z.any()",
         typeString: "any"
       };
     }
-    const properties = Object.entries(definition.properties);
     const schemaFields = [];
     const typeFields = [];
     for (const property of properties) {
@@ -653,6 +669,12 @@ class TemplateZod {
       schemaFields.push(result.schemaString);
       typeFields.push(result.typeString);
     }
+    if (definition?.type === "array") {
+      return {
+        schemaString: `z.array(z.object({${schemaFields.join(",")}}))`,
+        typeString: typeFields.join(";")
+      };
+    }
     return {
       schemaString: `z.object({${schemaFields.join(",")}})`,
       typeString: typeFields.join(";")
@@ -708,8 +730,8 @@ class TemplateZod {
           model2 = this.parseEnumItems(items);
         } else {
           return {
-            schemaString: `${schemaAttribute} z.array(z.unknown())${schemaRequired}`,
-            typeString: `${typeAttribute} z.unknown()[]${typeNullishability}`
+            schemaString: `${schemaAttribute} z.array(z.any())${schemaRequired}`,
+            typeString: `${typeAttribute} any[]${typeNullishability}`
           };
         }
         return {
@@ -860,13 +882,22 @@ class CodeGenerator {
           const isFormUrlEncoded = ParserUtils.isFormUrlEncoded(httpMethod, endpoint.consumes);
           const queryParams = ParserUtils.filterQueryParameters(endpoint.parameters);
           const pathParams = ParserUtils.filterPathParams(endpoint.parameters);
-          const bodyParams = ParserUtils.filterBodyParams(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,