@accelbyte/codegen 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/accelbyte-codegen.mjs

@@ -53,86 +53,6 @@ class CliParser {
   };
 }
 
-const Schema = z.object({
-  $ref: z.string().nullish(),
-  type: z.union([
-    z.literal("array"),
-    z.literal("object"),
-    z.literal("file"),
-    z.literal("string"),
-    z.literal("boolean")
-  ]).nullish(),
-  items: z.object({
-    $ref: z.string().nullish(),
-    type: z.string().nullish()
-  }).nullish(),
-  properties: z.array(z.string()).nullish(),
-  description: z.string().nullish(),
-  additionalProperties: z.object({
-    type: z.string().nullish()
-  }).nullish()
-});
-const Definition = z.object({
-  required: z.array(z.string()).nullish(),
-  properties: z.record(z.object({
-    type: z.string()
-  })).nullish()
-});
-const Definitions = z.record(Definition);
-const EndpointParametersType = z.enum(["apiKey", "boolean", "int", "integer", "number", "string", "array", "file"]);
-const EndpointParametersIn = z.enum(["body", "formData", "header", "path", "query"]);
-const EndpointParameters = z.object({
-  type: EndpointParametersType.nullish(),
-  description: z.string().nullish(),
-  name: z.string(),
-  in: EndpointParametersIn,
-  required: z.boolean().nullish(),
-  schema: Schema.nullish(),
-  default: z.union([z.boolean(), z.string(), z.number()]).nullish(),
-  enum: z.array(z.union([z.boolean(), z.string(), z.number()])).nullish(),
-  items: z.object({
-    type: z.string()
-  }).nullish()
-});
-const Endpoint = z.object({
-  description: z.string().nullish(),
-  consumes: z.array(z.string()).nullish(),
-  produces: z.array(z.string()).nullish(),
-  tags: z.array(z.string()).nullish(),
-  summary: z.string().nullish(),
-  operationId: z.string(),
-  deprecated: z.boolean().nullish(),
-  responses: z.record(z.object({
-    description: z.string().nullish(),
-    schema: Schema.nullish()
-  })),
-  parameters: z.array(EndpointParameters).nullish()
-});
-const Operation = z.object({
-  get: Endpoint.nullish(),
-  post: Endpoint.nullish(),
-  patch: Endpoint.nullish(),
-  delete: Endpoint.nullish(),
-  put: Endpoint.nullish()
-});
-const Paths = z.record(Operation);
-z.object({
-  paths: Paths,
-  definitions: Definitions,
-  basePath: z.string(),
-  info: z.object({
-    description: z.string(),
-    title: z.string(),
-    contact: z.object({
-      name: z.string(),
-      url: z.string(),
-      email: z.string()
-    }),
-    version: z.string()
-  }),
-  schemes: z.array(z.string()).nullish()
-});
-
 const getImportableVarMap = () => ({
   "@accelbyte/sdk": ["CodeGenUtil", "SdkCache", "IResponse", "IResponseWithSync", "Validate"],
   axios: ["AxiosRequestConfig", "AxiosResponse"],
@@ -184,10 +104,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) => {
@@ -240,12 +164,21 @@ class ParserUtils {
     if (definition.type && ParserUtils.parseType(definition) === "number") {
       return `${attrName}${required}: number`;
     }
+    if (definition?.schema?.type && ParserUtils.parseType(definition) === "number") {
+      return `${attrName}${required}: number`;
+    }
     if (definition.type && definition.type === "array") {
       return `${attrName}${required}: ${definition.items.type ?? "any"}[]`;
     }
+    if (definition?.schema?.type && definition.schema.type === "array") {
+      return `${attrName}${required}: ${definition.schema.items.type ?? "any"}[]`;
+    }
     if (definition.type && definition.type) {
       return `${attrName}${required}: ${definition.type} | null`;
     }
+    if (definition?.schema?.type && definition.schema.type) {
+      return `${attrName}${required}: ${definition.schema.type} | null`;
+    }
     return `${attrName}${required}: any`;
   };
   static parseBodyParamsType = (bodyParams) => {
@@ -277,11 +210,14 @@ class ParserUtils {
     keys.forEach((key) => {
       if (String(key).startsWith("2")) {
         const sch = methodEntity[key].schema;
+        const schV3 = methodEntity[key].content && methodEntity[key].content["application/json"].schema;
         if (sch?.$ref) {
           responseClass = ParserUtils.parseRefType(sch.$ref);
         } else if (sch?.type === "array" && sch.items?.$ref) {
           responseClass = ParserUtils.parseRefType(sch.items.$ref);
           responseClass = `${responseClass}Array`;
+        } else if (schV3?.$ref) {
+          responseClass = ParserUtils.parseRefType(schV3.$ref);
         } else ;
       }
     });
@@ -414,7 +350,104 @@ ${content}`;
   };
 }
 
-const templateJsdocMethod = ({ classMethod, httpMethod, path, pathParams, bodyParams, queryParams }) => {
+const Schema = z.object({
+  $ref: z.string().nullish(),
+  type: z.union([z.literal("array"), z.literal("object"), z.literal("file"), z.literal("string"), z.literal("boolean"), z.literal("integer")]).nullish(),
+  items: z.object({
+    $ref: z.string().nullish(),
+    type: z.string().nullish()
+  }).nullish(),
+  properties: z.union([z.array(z.string()).nullish(), z.record(z.object({ type: z.string() })).nullish()]),
+  description: z.string().nullish(),
+  additionalProperties: z.object({
+    type: z.string().nullish()
+  }).nullish()
+});
+const Definition = z.object({
+  required: z.array(z.string()).nullish(),
+  properties: z.record(z.object({
+    type: z.string()
+  })).nullish()
+});
+const Definitions = z.record(Definition);
+const EndpointParametersType = z.enum(["apiKey", "boolean", "int", "integer", "number", "string", "array", "file"]);
+const EndpointParametersIn = z.enum(["body", "formData", "header", "path", "query"]);
+const EndpointParameters = z.object({
+  type: EndpointParametersType.nullish(),
+  description: z.string().nullish(),
+  name: z.string(),
+  in: EndpointParametersIn,
+  required: z.boolean().nullish(),
+  schema: Schema.nullish(),
+  default: z.union([z.boolean(), z.string(), z.number()]).nullish(),
+  enum: z.array(z.union([z.boolean(), z.string(), z.number()])).nullish(),
+  items: z.object({
+    type: z.string()
+  }).nullish()
+});
+const Endpoint = z.object({
+  description: z.string().nullish(),
+  consumes: z.array(z.string()).nullish(),
+  produces: z.array(z.string()).nullish(),
+  tags: z.array(z.string()).nullish(),
+  summary: z.string().nullish(),
+  operationId: z.string(),
+  deprecated: z.boolean().nullish(),
+  responses: z.record(z.object({
+    description: z.string().nullish(),
+    schema: Schema.nullish(),
+    content: z.object({
+      "application/json": z.object({
+        schema: Schema.nullish()
+      })
+    }).nullish()
+  })),
+  parameters: z.array(EndpointParameters).nullish(),
+  requestBody: z.object({
+    required: z.boolean(),
+    content: z.object({
+      "application/json": z.object({
+        schema: Schema.nullish()
+      })
+    }).nullish()
+  }).nullish()
+});
+const Operation = z.object({
+  get: Endpoint.nullish(),
+  post: Endpoint.nullish(),
+  patch: Endpoint.nullish(),
+  delete: Endpoint.nullish(),
+  put: Endpoint.nullish()
+});
+const Paths = z.record(Operation);
+z.object({
+  paths: Paths,
+  definitions: Definitions,
+  basePath: z.string(),
+  info: z.object({
+    description: z.string(),
+    title: z.string(),
+    contact: z.object({
+      name: z.string(),
+      url: z.string(),
+      email: z.string()
+    }),
+    version: z.string()
+  }),
+  schemes: z.array(z.string()).nullish(),
+  components: z.object({
+    schemas: Definitions
+  }).nullish()
+});
+
+const templateJsdocMethod = ({
+  classMethod,
+  httpMethod,
+  path,
+  pathParams,
+  bodyParams,
+  queryParams
+}) => {
   let jsdoc = "";
   let methodSignature = "";
   let newPath = path;
@@ -594,13 +627,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) {
@@ -609,6 +646,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(";")
@@ -650,7 +693,8 @@ class TemplateZod {
         };
       }
       if (type === "array") {
-        const ref2 = definition.items?.$ref;
+        const items = definition.items;
+        const ref2 = items?.$ref;
         let model2;
         if (ref2) {
           const refType = ParserUtils.parseRefType(ref2);
@@ -659,9 +703,13 @@ class TemplateZod {
             schemaString: refType,
             typeString: refType
           };
-        } else {
-          const items = definition.items;
+        } else if (items) {
           model2 = this.parseEnumItems(items);
+        } else {
+          return {
+            schemaString: `${schemaAttribute} z.array(z.any())${schemaRequired}`,
+            typeString: `${typeAttribute} any[]${typeNullishability}`
+          };
         }
         return {
           schemaString: `${schemaAttribute} z.array(${model2.schemaString})${schemaRequired}`,
@@ -811,13 +859,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,
@@ -868,8 +925,9 @@ class CodeGenerator {
       indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default.join(DIST_DIR, `${classGenName}`), targetSrcFolder));
     }
     const duplicates = /* @__PURE__ */ new Map();
-    for (const ref in api.definitions) {
-      const definition = api.definitions[ref];
+    const definitions = api?.components?.schemas || api.definitions;
+    for (const ref in definitions) {
+      const definition = definitions[ref];
       let fileName = ParserUtils.parseRefType(ref);
       const fileExist = fs__default.existsSync(path__default.join(DIST_DEFINITION_DIR, `${fileName}.ts`));
       if (fileExist) {
@@ -880,8 +938,8 @@ class CodeGenerator {
       ParserUtils.writeDefinitionFile(DIST_DEFINITION_DIR, fileName, buffer);
       indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default.join(DIST_DEFINITION_DIR, fileName), targetSrcFolder));
     }
-    for (const ref in api.definitions) {
-      const definition = api.definitions[ref];
+    for (const ref in definitions) {
+      const definition = definitions[ref];
       const fileName = ParserUtils.parseRefType(ref);
       const { buffer, duplicateFound } = new TemplateZod().render(fileName, definition, duplicates);
       if (duplicateFound) {