@accelbyte/codegen 3.0.5 → 3.1.0

package/dist/accelbyte-codegen.js

@@ -89,7 +89,7 @@ const makeNewImportVarMap$1 = () => ({
   axios: ["AxiosInstance"],
   "@accelbyte/sdk": ["SDKRequestConfig"]
 });
-const generateImports = (body, importStatements, makeNewImportVarMap2, getImportableVarMap2) => {
+const generateImports$1 = (body, importStatements, makeNewImportVarMap2, getImportableVarMap2) => {
   const usedImportVarMap = makeNewImportVarMap2;
   const importableVarMap = getImportableVarMap2;
   for (const [moduleSource, importableVars] of Object.entries(importableVarMap)) {
@@ -110,16 +110,55 @@ const templateClass = (className, body, importStatements) => {
   return `/**
  * AUTO GENERATED
  */
-${generateImports(body, importStatements, makeNewImportVarMap$1(), getImportableVarMap$1())}
+${generateImports$1(body, importStatements, makeNewImportVarMap$1(), getImportableVarMap$1())}
 
 export class ${className} {
   // @ts-ignore
-  constructor(private axiosInstance: AxiosInstance, private namespace: string, private isValidationEnabled = true) {}
+  constructor(private axiosInstance: AxiosInstance, private namespace: string, private useSchemaValidation = true) {}
   ${body}
 }
   `;
 };
 
+const generateImports = (body, className) => {
+  const generatedImports = `import { AccelbyteSDK, ApiArgs, ApiError } from '@accelbyte/sdk'
+import { AxiosError } from 'axios'
+// @ts-ignore
+import { useQuery, UseQueryOptions, UseQueryResult, useMutation, UseMutationOptions, UseMutationResult } from '@tanstack/react-query'
+import { ${className} } from "../${className}.js"
+`;
+  return generatedImports;
+};
+const templateQuery = (className, body, importStatements, serviceNameTitle, returnMethods, paramImports) => {
+  const classNameWithoutApi = className.replace("Api", "");
+  const queryKeys = ParserUtils.createQueryKeys(classNameWithoutApi, returnMethods);
+  const generatedImports = generateImports(body, className);
+  return `/**
+ * AUTO GENERATED
+ */
+/* eslint-disable camelcase */
+${generatedImports}
+${filterUsedImports(paramImports, body)}
+
+export enum Key_${classNameWithoutApi} {
+  ${queryKeys}
+}
+
+  ${body}
+  `;
+};
+function filterUsedImports(importArr, body) {
+  return importArr.filter((path) => {
+    const start = path.indexOf("{") + 1;
+    const end = path.indexOf("}");
+    if (start > 0 && end > start) {
+      const importName = path.slice(start, end).trim();
+      return body.includes(importName);
+    }
+    return false;
+  }).map((path) => path).join("\n") + "\n";
+}
+
 const getImportableVarMap = () => ({
   "@accelbyte/sdk": ["CodeGenUtil", "IResponse", "Validate", "ApiArgs", "Network", "AccelbyteSDK"]
 });
@@ -127,18 +166,22 @@ const makeNewImportVarMap = () => ({
   "@accelbyte/sdk": ["AccelbyteSDK", "ApiArgs", "ApiUtils"]
 });
 const templateApiClass = (className, body, importStatements, returnMethods) => {
+  const $className = className.replace("Api", "$");
   return `/**
  * AUTO GENERATED
  */
 /* eslint-disable camelcase */
-${generateImports(body, importStatements, makeNewImportVarMap(), getImportableVarMap())}
+// @ts-ignore -> ts-expect-error TS6133
+${generateImports$1(body, importStatements, makeNewImportVarMap(), getImportableVarMap())}
+${`import { ${$className} } from './endpoints/${$className}.js'
+`}
 
 export function ${className}(sdk: AccelbyteSDK, args?: ApiArgs) {
   const sdkAssembly = sdk.assembly()
   
   const namespace = args?.namespace ? args?.namespace : sdkAssembly.namespace
   const requestConfig = ApiUtils.mergedConfigs(sdkAssembly.config, args)
-  const isValidationEnabled = args?.isValidationEnabled !== false
+  const useSchemaValidation = sdkAssembly.useSchemaValidation
   ${body}
   
   return {
@@ -228,8 +271,35 @@ const REMOVED_KEYWORDS = [
   "/{namespace}/"
 ];
 class ParserUtils {
-  static replaceAll = (string, search, replace) => {
-    return string.split(search).join(replace);
+  static createQueryKeys(classNameWithoutApi, csvMethodNames) {
+    const keys = csvMethodNames.split(",");
+    const processedKeys = /* @__PURE__ */ new Set();
+    const enumString = keys.reduce((acc, key, index) => {
+      const trimmedKey = key.trim();
+      const isDeprecated = key.indexOf("_DEPRECATED") > 0;
+      if (trimmedKey && !isDeprecated) {
+        const cleanedKey = trimmedKey.replace(/^(get|update|create|patch|delete)[_]?/, "");
+        if (!processedKeys.has(cleanedKey)) {
+          processedKeys.add(cleanedKey);
+          acc += `${cleanedKey} = '${classNameWithoutApi}.${cleanedKey}'`;
+          if (index < keys.length - 1) {
+            acc += ",\n";
+          }
+        }
+      }
+      return acc;
+    }, "");
+    return enumString;
+  }
+  static addDeprecatedSuffix(isDeprecated, methodName) {
+    if (isDeprecated) {
+      return methodName + "_DEPRECATED";
+    } else {
+      return methodName;
+    }
+  }
+  static replaceAll = (text, search, replace) => {
+    return text.split(search).join(replace);
   };
   static generateClassName = (tag, isAdmin) => {
     const className = _.upperFirst(_.camelCase(tag));
@@ -369,7 +439,7 @@ class ParserUtils {
     if (bodyParam?.schema?.type === "array" && bodyParam?.schema?.items?.$ref) {
       return `${ParserUtils.parseRefType(bodyParam.schema.items.$ref)}[]`;
     }
-    if (bodyParam?.schema.$ref) {
+    if (bodyParam?.schema?.$ref) {
       return ParserUtils.parseRefType(bodyParam.schema.$ref);
     }
     if (bodyParam?.schema?.additionalProperties?.type === "object") {
@@ -485,6 +555,20 @@ class ParserUtils {
     const fileContent = templateClass(apiName, apiBuffer, imports);
     fs.writeFileSync(`${distDir}/${apiName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
   }
+  static writeAtomFile(distDir, apiName, fileContent) {
+    ParserUtils.mkdirIfNotExist(distDir);
+    fs.writeFileSync(`${distDir}/${apiName}.atom.ts`, ParserUtils.prependCopyrightHeader(fileContent));
+  }
+  static writeQueryFile(distDir, apiName, apiBuffer, imports, serviceNameTitle, returnMethods, paramImports) {
+    if (apiBuffer.length < 1) {
+      return null;
+    }
+    const queryFileName = `${apiName.replace("Api", "")}.query`;
+    ParserUtils.mkdirIfNotExist(distDir);
+    const fileContent = templateQuery(apiName, apiBuffer, imports, serviceNameTitle, returnMethods, paramImports);
+    fs.writeFileSync(`${distDir}/${queryFileName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
+    return queryFileName;
+  }
   static writeXVersion(distDir, xversionJson, apiInfo) {
     if (xversionJson) {
       console.log("x-version:", xversionJson);
@@ -955,7 +1039,7 @@ const apis = {
 ${returnStatement}
 }
 
-export const ${ParserUtils.convertDashesToTitleCase(serviceNameTitle)} = apis
+export const ${serviceNameTitle} = apis
   `;
 };
 
@@ -1014,11 +1098,11 @@ const Endpoint = zod.z.object({
   })),
   parameters: zod.z.array(EndpointParameters).nullish(),
   requestBody: zod.z.object({
-    required: zod.z.boolean(),
+    required: zod.z.boolean().nullish(),
     content: zod.z.object({
       "application/json": zod.z.object({
         schema: Schema.nullish()
-      })
+      }).nullish()
     }).nullish()
   }).nullish(),
   "x-security": zod.z.any().nullish()
@@ -1116,10 +1200,6 @@ const templateMethod = ({
   methodParams = (queryParamsType ? `${methodParams} ${queryParamsType}` : methodParams).replace(/,\s*$/, "");
   methodParamsNoTypes = queryParamsType ? `${methodParamsNoTypes} queryParams` : methodParamsNoTypes;
   let methodImpl = "";
-  const isCacheFetch = ["get"].includes(httpMethod) && resolvedResponseClass !== "unknown";
-  const deprecateTag = isCacheFetch ? `/**
- * @deprecated Use "${classMethod}()" instead.
- */` : "";
   const isGuardInvoked = ["get", "post", "put", "patch", "delete"].includes(httpMethod);
   const responseType = resolvedResponseClass !== "unknown" ? `${resolvedResponseClass}` : "unknown";
   const generateMethodName = () => `${classMethod}(${methodParams}): Promise<${responseSyncType}<${responseType}>>`;
@@ -1130,18 +1210,11 @@ const templateMethod = ({
     const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
     const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
 
-${`    return Validate.validateOrReturnResponse(this.isValidationEnabled, () => resultPromise, ${resolvedResponseClassValidated}, '${resolvedResponseClassValidated}')`}
+${`    return Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, ${resolvedResponseClassValidated}, '${resolvedResponseClassValidated}')`}
   }
   `;
   if (!isGuardInvoked) {
-    methodImpl = `${descriptionText}
-      ${deprecateTag}
-  TODO_${classMethod}(${methodParams}): Promise<AxiosResponse<${resolvedResponseClass}>> {
-    ${queryParamsDefault}
-    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
-    return this.axiosInstance.${httpMethod}(url, ${dataPayload})
-  }
-    `;
+    methodImpl = ``;
   }
   const res = {
     methodImpl,
@@ -1203,7 +1276,7 @@ const templateApiMethod = ({
   const methodImpl = `
   ${descriptionText}
   async function ${classMethod}(${methodParams}): Promise<${responseType}> {
-    const $ = new ${classGenName}(Network.create(requestConfig), namespace, isValidationEnabled)
+    const $ = new ${classGenName}(Network.create(requestConfig), namespace, useSchemaValidation)
     const resp = await $.${classMethod}(${methodParamsNoTypes})
     if (resp.error) throw resp.error
     return resp.response.data
@@ -1266,6 +1339,151 @@ const normalizeMethodSnippet = (methodInput, splitWord) => {
   return result;
 };
 
+const templateQueryMethod = ({
+  classMethod,
+  httpMethod,
+  path,
+  pathParams,
+  responseClass,
+  methodParams,
+  apiGenName,
+  isFormUrlEncoded,
+  deprecated
+}) => {
+  if (isFormUrlEncoded || deprecated) {
+    return "";
+  }
+  const isPostFetch = httpMethod === "post" && (path.includes("/table-query/") || path.endsWith("/list"));
+  const isAdmin = path.indexOf("/admin/") > 0;
+  const isGet = httpMethod === "get" || isPostFetch;
+  let queryMethod = isGet ? "useQuery" : "useMutation";
+  let mParams = "";
+  let mParamsNoTypes = "";
+  let newPath = `'${path}'`;
+  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path);
+  for (const pathParam of sortedPathParams) {
+    const type = ParserUtils.parseType(pathParam);
+    if (pathParam.name !== "namespace") {
+      mParams += pathParam.name + `:${type}, `;
+      mParamsNoTypes += pathParam.name + ", ";
+    }
+    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}))`;
+      }
+    }
+  }
+  const resolvedResponseClass = responseClass || "unknown";
+  let _methodName = convertMethodName(classMethod, isPostFetch);
+  _methodName = isAdmin ? _methodName.replace("use", "useAdm") : _methodName;
+  const _responseType = resolvedResponseClass !== "unknown" ? `${resolvedResponseClass}` : "unknown";
+  const _methodParams = methodParams && methodParams.length > 0 ? `& { ${methodParams} }` : "";
+  const _methodParamsImpl = convertToMethodImplArgs(methodParams);
+  const queryMethodImpl = `
+
+export const ${_methodName} = (
+    sdk: AccelbyteSDK,
+    input: ApiArgs ${_methodParams},
+    options?: Omit<UseQueryOptions<${_responseType}, AxiosError<ApiError>>, 'queryKey'>,
+    callback?: (data: ${_responseType}) => void
+  ): UseQueryResult<${_responseType}, AxiosError<ApiError>> => { 
+  //
+  const queryFn = (
+  sdk: AccelbyteSDK, 
+  input: Parameters<typeof ${_methodName}>[1]
+  ) => async () => {
+      const data = 
+            (await ${apiGenName}(sdk, { namespace: input.namespace }).
+                ${classMethod}(${_methodParamsImpl}))
+      callback && callback(data)
+      return data
+  }
+  
+  return ${queryMethod}<${_responseType}, AxiosError<ApiError>>({
+    queryKey: [${createQueryKey(apiGenName, classMethod)}, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  })
+}
+  
+  `;
+  const mutationMethodImpl = `
+
+export const ${_methodName} = (
+    sdk: AccelbyteSDK,
+    options?: Omit<UseMutationOptions<${_responseType}, AxiosError<ApiError>, ApiArgs ${_methodParams}>, 'mutationKey'>,
+    callback?: (data: ${_responseType}) => void
+  ): UseMutationResult<${_responseType}, AxiosError<ApiError>, ApiArgs ${_methodParams}> => { 
+  //
+  const mutationFn = async (input: ApiArgs ${_methodParams}) => {
+      const data = 
+            (await ${apiGenName}(sdk, { namespace: input.namespace, config: input.config }).
+                ${classMethod}(${_methodParamsImpl}))
+      callback && callback(data)
+      return data
+  }
+  
+  return useMutation({
+    mutationKey: [${createQueryKey(apiGenName, classMethod)}],
+    mutationFn,
+    ...options
+  })
+}
+  
+  `;
+  return isGet ? queryMethodImpl : mutationMethodImpl;
+};
+function createQueryKey(className, methodName) {
+  if (methodName.indexOf("_DEPRECATED") > 0) {
+    return "";
+  }
+  const prefixRegex = /^(get|create|update|delete|patch)[_]?/i;
+  const cleanedMethodName = methodName.replace(prefixRegex, "").trim();
+  const finalMethodName = cleanedMethodName.charAt(0).toUpperCase() + cleanedMethodName.slice(1);
+  return `Key_${className.replace("Api", "")}.${finalMethodName}`;
+}
+const prefixMappings = {
+  get: "use",
+  create: "useCreate",
+  patch: "usePatch",
+  update: "useUpdate",
+  delete: "useDelete"
+};
+function convertMethodName(classMethod, isPostFetch) {
+  for (const [originalPrefix, newPrefix] of Object.entries(prefixMappings)) {
+    if (classMethod.startsWith(originalPrefix)) {
+      if (isPostFetch) {
+        return classMethod.replace(originalPrefix, "useFetch");
+      }
+      const newMethodName = classMethod.replace(originalPrefix, newPrefix);
+      if (originalPrefix === "get") {
+        return newMethodName;
+      } else {
+        return newMethodName + "Mutation";
+      }
+    }
+  }
+  return classMethod;
+}
+function convertToMethodImplArgs(methodArgs) {
+  let properties = methodArgs.split(/,\s*(?![^{}]*\})/).map((prop) => prop.trim()).filter(Boolean);
+  let formattedProperties = [];
+  properties.forEach((prop) => {
+    if (prop.includes(": {")) {
+      const propertyName = prop.split(": {")[0].replace("?", "").trim();
+      formattedProperties.push(`input.${propertyName}`);
+    } else {
+      const colonIndex = prop.indexOf(":");
+      const propertyName = prop.substring(0, colonIndex).replace("?", "").trim();
+      formattedProperties.push(`input.${propertyName}`);
+    }
+  });
+  return formattedProperties.join(", ");
+}
+
 const GIT_URL = "https://github.com/AccelByte/accelbyte-web-sdk/blob/main/packages";
 class SwaggerReaderHelpers {
   static getServicePrefix = (servicePaths) => servicePaths[servicePaths.length - 1].split("/")[1];
@@ -1282,7 +1500,8 @@ class SwaggerReaderHelpers {
         tagToEndpointClassesRecord: {},
         tagToSdkClientRecord: {},
         tagToSdkFunctionNamesRecord: {},
-        tagToSdkImportsRecord: {}
+        tagToSdkImportsRecord: {},
+        tagToEndpointQueryRecord: {}
       },
       public: {
         arrayDefinitions: [],
@@ -1291,7 +1510,8 @@ class SwaggerReaderHelpers {
         tagToEndpointClassesRecord: {},
         tagToSdkClientRecord: {},
         tagToSdkFunctionNamesRecord: {},
-        tagToSdkImportsRecord: {}
+        tagToSdkImportsRecord: {},
+        tagToEndpointQueryRecord: {}
       }
     };
     const sortedPathsByLength = new Map(Object.entries(api.paths).sort((a, b) => {
@@ -1320,7 +1540,8 @@ class SwaggerReaderHelpers {
         tagToEndpointClassesRecord,
         tagToSdkClientRecord,
         tagToSdkFunctionNamesRecord,
-        tagToSdkImportsRecord
+        tagToSdkImportsRecord,
+        tagToEndpointQueryRecord
       } = picked;
       const tagToClassMethodsMapByType = isAdminEndpoint ? tagToClassMethodsMap.admin : tagToClassMethodsMap.public;
       const httpMethods = Object.keys(operation);
@@ -1367,12 +1588,12 @@ class SwaggerReaderHelpers {
             {
               name: "body",
               in: "body",
-              schema: endpoint.requestBody.content["application/json"].schema
+              schema: endpoint.requestBody.content["application/json"]?.schema
             }
           ];
         }
         const { methodImpl, methodParams, methodParamsNoTypes, importStatements } = templateMethod({
-          classMethod,
+          classMethod: ParserUtils.addDeprecatedSuffix(deprecated, classMethod),
           description,
           httpMethod,
           path: pathWithBase,
@@ -1384,8 +1605,21 @@ class SwaggerReaderHelpers {
           deprecated
         });
         tagToEndpointClassesRecord[tag] = (tagToEndpointClassesRecord[tag] || "") + methodImpl;
+        const { apiGenName } = ParserUtils.generateApiName(tag, isAdminEndpoint);
+        const queryMethodImpl = templateQueryMethod({
+          classMethod: ParserUtils.addDeprecatedSuffix(deprecated, classMethod),
+          httpMethod,
+          path: pathWithBase,
+          pathParams,
+          responseClass,
+          methodParams,
+          apiGenName,
+          isFormUrlEncoded,
+          deprecated
+        });
+        tagToEndpointQueryRecord[tag] = (tagToEndpointQueryRecord[tag] || "") + queryMethodImpl;
         const { generatedMethodString, snippetApiArgs, snippetMethod, snippetShell } = templateApiMethod({
-          classMethod,
+          classMethod: ParserUtils.addDeprecatedSuffix(deprecated, classMethod),
           description,
           httpMethod,
           path: pathWithBase,
@@ -1399,11 +1633,15 @@ class SwaggerReaderHelpers {
           xSecurity: endpoint["x-security"]
         });
         tagToSdkClientRecord[tag] = (tagToSdkClientRecord[tag] || "") + generatedMethodString;
-        tagToSdkFunctionNamesRecord[tag] = (tagToSdkFunctionNamesRecord[tag] || "") + classMethod + ",";
+        tagToSdkFunctionNamesRecord[tag] = (tagToSdkFunctionNamesRecord[tag] || "") + ParserUtils.addDeprecatedSuffix(deprecated, classMethod) + ",";
         tagToSdkImportsRecord[tag] = tagToSdkImportsRecord[tag] ? [.../* @__PURE__ */ new Set([...importStatements, ...tagToSdkImportsRecord[tag]])] : [...new Set(importStatements)];
         const serviceNameTitle = ParserUtils.convertDashesToTitleCase(serviceName);
-        const { apiGenName } = ParserUtils.generateApiName(tag, isAdminEndpoint);
-        const resultSnippet = templateSdkSnippet({ serviceNameTitle, apiName: apiGenName, snippetMethod, snippetApiArgs });
+        const resultSnippet = templateSdkSnippet({
+          serviceNameTitle,
+          apiName: apiGenName,
+          snippetMethod,
+          snippetApiArgs
+        });
         const currentSnippetMap = {};
         snippetMap[pathWithBase][httpMethod] = currentSnippetMap;
         currentSnippetMap.web = resultSnippet;
@@ -1423,12 +1661,13 @@ class CodeGenerator {
   static srcFolder = () => CliParser.getOutputPath();
   static getGeneratedFolder = (isAdmin) => isAdmin ? `${CodeGenerator.srcFolder()}/generated-admin` : `${CodeGenerator.srcFolder()}/generated-public`;
   static getGeneratedSnippetsFolder = () => `${CliParser.getSnippetOutputPath()}/generated-snippets`;
-  static prepareDirs = (DIST_DEFINITION_DIR, DIST_DIR, DIST_DIR_ENDPOINTS) => {
+  static prepareDirs = (DIST_DEFINITION_DIR, DIST_DIR, DIST_DIR_ENDPOINTS, DIST_DIR_QUERIES) => {
     ParserUtils.mkdirIfNotExist(DIST_DEFINITION_DIR);
     ParserUtils.mkdirIfNotExist(DIST_DIR(true));
     ParserUtils.mkdirIfNotExist(DIST_DIR(false));
     ParserUtils.mkdirIfNotExist(DIST_DIR_ENDPOINTS(true));
     ParserUtils.mkdirIfNotExist(DIST_DIR_ENDPOINTS(false));
+    ParserUtils.mkdirIfNotExist(DIST_DIR_QUERIES(true));
   };
   static main = async (nameArray) => {
     const serviceName = nameArray[0];
@@ -1456,9 +1695,10 @@ class CodeGenerator {
     }
     const DIST_DIR = (isAdmin) => `${CodeGenerator.getGeneratedFolder(isAdmin)}`;
     const DIST_DIR_ENDPOINTS = (isAdmin) => path.join(DIST_DIR(isAdmin), "endpoints");
+    const DIST_DIR_QUERIES = (isAdmin) => path.join(DIST_DIR(isAdmin), "queries");
     const DIST_DEFINITION_DIR = path.join(CodeGenerator.srcFolder(), "generated-definitions");
     const targetSrcFolder = `${CodeGenerator.srcFolder()}/`;
-    CodeGenerator.prepareDirs(DIST_DEFINITION_DIR, DIST_DIR, DIST_DIR_ENDPOINTS);
+    CodeGenerator.prepareDirs(DIST_DEFINITION_DIR, DIST_DIR, DIST_DIR_ENDPOINTS, DIST_DIR_QUERIES);
     const mainApiList = [];
     const generatePublicOrAdmin = (isAdmin) => {
       const parsedInformationByType = isAdmin ? parsedInformation.admin : parsedInformation.public;
@@ -1468,7 +1708,8 @@ class CodeGenerator {
         tagToEndpointClassesRecord,
         tagToSdkClientRecord,
         tagToSdkFunctionNamesRecord,
-        tagToSdkImportsRecord
+        tagToSdkImportsRecord,
+        tagToEndpointQueryRecord
       } = parsedInformationByType;
       const writeApiEndpointFiles = (isAdminEndpoint) => {
         const apiList = [];
@@ -1479,12 +1720,15 @@ class CodeGenerator {
           const apiImports = [.../* @__PURE__ */ new Set([...tagToSdkImportsRecord[tag], ...Object.values(tagToClassImportsRecord[className])])];
           apiImports.push(`import { ${classGenName} } from './endpoints/${classGenName}.js'`);
           ParserUtils.writeClassFile(DIST_DIR_ENDPOINTS(isAdminEndpoint), classGenName, classBuffer, imports);
-          const apiBuffer = tagToSdkClientRecord[tag];
           const { apiGenName } = ParserUtils.generateApiName(tag, isAdminEndpoint);
-          ParserUtils.writeApiFile(DIST_DIR(isAdminEndpoint), apiGenName, apiBuffer, apiImports, tagToSdkFunctionNamesRecord[tag]);
+          const queryBuffer = tagToEndpointQueryRecord[tag];
+          const queryFileName = ParserUtils.writeQueryFile(DIST_DIR_QUERIES(isAdminEndpoint), apiGenName, queryBuffer, apiImports, serviceNameTitle, tagToSdkFunctionNamesRecord[tag], imports);
+          const apiBuffer = tagToSdkClientRecord[tag];
+          ParserUtils.writeApiFile(DIST_DIR(isAdminEndpoint), apiGenName, apiBuffer, imports, tagToSdkFunctionNamesRecord[tag]);
           apiList.push(apiGenName);
           indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(DIST_DIR_ENDPOINTS(isAdminEndpoint), `${classGenName}`), targetSrcFolder));
           indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(DIST_DIR(isAdminEndpoint), `${apiGenName}`), targetSrcFolder));
+          queryFileName && indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(DIST_DIR(isAdminEndpoint), "queries", `${queryFileName}`), targetSrcFolder));
         }
         mainApiList.push(...apiList);
         indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(CodeGenerator.srcFolder(), serviceNameTitle), targetSrcFolder));
@@ -1596,7 +1840,7 @@ const generateSdk = async () => {
       }
     });
   }
-  const indexImportsArray = Array.from(indexImportsSet);
+  const indexImportsArray = Array.from(indexImportsSet).sort();
   const filesToImport = indexImportsArray.map((fileToImport) => {
     return `export * from '${fileToImport.replace("\\", "/")}.js'`;
   });