@accelbyte/codegen 4.0.1 → 4.1.0

package/dist/accelbyte-codegen.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
+import path7 from "path";
 import yargs from "yargs";
-import path6 from "path";
 
 // src/CliParser.ts
 import fs from "fs";
@@ -55,6 +55,12 @@ var CliParser = class _CliParser {
   static isGenerateSnippetOnly = () => {
     return _CliParser.instance().argv.snippetOnly;
   };
+  static getWebSocketSchemaPath = () => {
+    return _CliParser.instance().argv.webSocketSchema;
+  };
+  static isGenerateWebSocket = () => {
+    return !!_CliParser.getWebSocketSchemaPath();
+  };
 };
 
 // src/CodeGenerator.ts
@@ -301,15 +307,15 @@ export enum Key_${classNameWithoutApi} {
   `;
 };
 function filterUsedImports(importArr, body) {
-  return importArr.filter((path7) => {
-    const start = path7.indexOf("{") + 1;
-    const end = path7.indexOf("}");
+  return importArr.filter((path8) => {
+    const start = path8.indexOf("{") + 1;
+    const end = path8.indexOf("}");
     if (start > 0 && end > start) {
-      const importName = path7.slice(start, end).trim();
+      const importName = path8.slice(start, end).trim();
       return body.includes(importName);
     }
     return false;
-  }).map((path7) => path7).join("\n") + "\n";
+  }).map((path8) => path8).join("\n") + "\n";
 }
 
 // src/ParserUtils.ts
@@ -326,8 +332,8 @@ var REMOVED_KEYWORDS = [
   "/{namespace}/"
 ];
 var ParserUtils = class _ParserUtils {
-  static getVersionSuffixFromPath(path7) {
-    const version2_3_4_etc = path7.match(/\/v([2-9]|[1-9]\d+)\/+/);
+  static getVersionSuffixFromPath(path8) {
+    const version2_3_4_etc = path8.match(/\/v([2-9]|[1-9]\d+)\/+/);
     const methodSuffix = version2_3_4_etc ? `_v${version2_3_4_etc[1]}` : "";
     return methodSuffix;
   }
@@ -522,14 +528,14 @@ var ParserUtils = class _ParserUtils {
    * to this
    * `createGenerateByRequestIdByUserId`
    */
-  static generateNaturalLangMethod = ({ servicePrefix, path: path7, httpMethod, isForm, existingMethods, permissionType }) => {
-    let path_ = path7;
+  static generateNaturalLangMethod = ({ servicePrefix, path: path8, httpMethod, isForm, existingMethods, permissionType }) => {
+    let path_ = path8;
     path_ = path_.replace(`/${servicePrefix}/`, "/");
     REMOVED_KEYWORDS.forEach((prefix) => {
       path_ = path_.replace(prefix, "/");
     });
     path_ = path_.substring(1);
-    const isPlural = httpMethod === "get" && !(path7.slice(-1) === "}");
+    const isPlural = httpMethod === "get" && !(path8.slice(-1) === "}");
     if (!isPlural) {
       path_ = _ParserUtils.replaceAll(path_, "ies/", "y/");
       path_ = _ParserUtils.replaceAll(path_, "s/", "/");
@@ -572,9 +578,9 @@ var ParserUtils = class _ParserUtils {
     const genPath = _.upperFirst(lastWords) + "/" + listBeforeLastWords.join("/") + listByParams.reverse().join("/");
     let generatedMethod = _.camelCase(mappedMethod(httpMethod, isForm, permissionType) + genPath);
     generatedMethod = _ParserUtils.replaceAll(generatedMethod, "Byword", "_By");
-    const testedGeneratedMethod = generatedMethod + _ParserUtils.getVersionSuffixFromPath(path7);
-    generatedMethod = resolveConflicts({ path: path7, generatedMethod, testedGeneratedMethod, existingMethods });
-    generatedMethod = generatedMethod + _ParserUtils.getVersionSuffixFromPath(path7);
+    const testedGeneratedMethod = generatedMethod + _ParserUtils.getVersionSuffixFromPath(path8);
+    generatedMethod = resolveConflicts({ path: path8, generatedMethod, testedGeneratedMethod, existingMethods });
+    generatedMethod = generatedMethod + _ParserUtils.getVersionSuffixFromPath(path8);
     return generatedMethod;
   };
   static filterBodyParams(parameters) {
@@ -729,8 +735,8 @@ var ParserUtils = class _ParserUtils {
  */
 ${content}`;
   };
-  static sortPathParamsByPath = (pathParams, path7) => {
-    const params = path7.match(/{\w*}/g) || [];
+  static sortPathParamsByPath = (pathParams, path8) => {
+    const params = path8.match(/{\w*}/g) || [];
     const cleanParams = params.map((param) => param.replace("{", "").replace("}", ""));
     return pathParams.sort((a, b) => cleanParams.indexOf(a.name) - cleanParams.indexOf(b.name));
   };
@@ -754,30 +760,30 @@ var mappedMethod = (httpMethod, isForm, permissionType) => {
     return "delete";
   }
 };
-var resolveConflicts = ({ path: path7, generatedMethod, testedGeneratedMethod, existingMethods }) => {
+var resolveConflicts = ({ path: path8, generatedMethod, testedGeneratedMethod, existingMethods }) => {
   let _testedGenMethod = testedGeneratedMethod;
   try {
-    testConflict(path7, _testedGenMethod, existingMethods);
+    testConflict(path8, _testedGenMethod, existingMethods);
   } catch (e) {
-    if (path7.indexOf("/namespaces/") >= 0) {
+    if (path8.indexOf("/namespaces/") >= 0) {
       generatedMethod += "_ByNS";
       _testedGenMethod += "_ByNS";
     }
   }
   try {
-    testConflict(path7, _testedGenMethod, existingMethods);
+    testConflict(path8, _testedGenMethod, existingMethods);
   } catch (e) {
-    if (path7.indexOf("/admin/") >= 0) {
+    if (path8.indexOf("/admin/") >= 0) {
       generatedMethod += "_admin";
       _testedGenMethod += "_admin";
     }
   }
-  testConflict(path7, _testedGenMethod, existingMethods);
+  testConflict(path8, _testedGenMethod, existingMethods);
   return generatedMethod;
 };
-var testConflict = (path7, generatedMethod, existingMethods) => {
+var testConflict = (path8, generatedMethod, existingMethods) => {
   if (existingMethods[generatedMethod]) {
-    const conflictingMethod = { path: path7, generatedMethod };
+    const conflictingMethod = { path: path8, generatedMethod };
     throw Error(
       `Duplicate method conflict in ${JSON.stringify(conflictingMethod)},
  existingMethods: ${JSON.stringify(existingMethods, null, 2)}`
@@ -894,7 +900,7 @@ var OpenApiSpec = z2.object({
 var templateApiMethod = ({
   classMethod,
   httpMethod,
-  path: path7,
+  path: path8,
   pathParams,
   bodyParams,
   responseClasses,
@@ -903,12 +909,12 @@ var templateApiMethod = ({
   methodParamsNoTypes,
   xSecurity
 }) => {
-  let newPath = `'${path7}'`;
+  let newPath = `'${path8}'`;
   let snippetMethod = "";
   for (const pathParam of pathParams) {
     const type = ParserUtils.parseType(pathParam);
     const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
-    if (path7.match(`{${pathParam.name}}`)) {
+    if (path8.match(`{${pathParam.name}}`)) {
       if (type === "string") {
         newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
       } else {
@@ -916,9 +922,9 @@ var templateApiMethod = ({
       }
     }
   }
-  const snippetShellArgs = ["--location --request", `${httpMethod} '__DOMAIN__${path7}'`, "--header 'accept: application/json'"];
+  const snippetShellArgs = ["--location --request", `${httpMethod} '__DOMAIN__${path8}'`, "--header 'accept: application/json'"];
   const snippetApiArgs = [];
-  if (xSecurity !== void 0 || path7.includes("/admin")) {
+  if (xSecurity !== void 0 || path8.includes("/admin")) {
     snippetShellArgs.push("--header 'Authorization: Bearer {access_token}'");
     snippetApiArgs.push("{ axiosConfig: { request: { headers: { Authorization: 'Bearer {access_token}' } } } }".trim());
   }
@@ -956,7 +962,7 @@ var templateMethod = ({
   classMethod,
   description,
   httpMethod,
-  path: path7,
+  path: path8,
   pathParams,
   bodyParams,
   queryParams,
@@ -966,9 +972,9 @@ var templateMethod = ({
 }) => {
   let methodParams = "";
   let methodParamsNoTypes = "";
-  let newPath = `'${path7}'`;
+  let newPath = `'${path8}'`;
   let importStatements = [];
-  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path7);
+  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path8);
   for (const pathParam of sortedPathParams) {
     const type = ParserUtils.parseType(pathParam);
     if (pathParam.name !== "namespace") {
@@ -976,7 +982,7 @@ var templateMethod = ({
       methodParamsNoTypes += pathParam.name + ", ";
     }
     const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
-    if (path7.match(`{${pathParam.name}}`)) {
+    if (path8.match(`{${pathParam.name}}`)) {
       if (type === "string") {
         newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
       } else {
@@ -1041,7 +1047,7 @@ var POST_FETCH_INCLUDES_PATH = ["/table-query/"];
 var templateQueryMethod = ({
   classMethod,
   httpMethod,
-  path: path7,
+  path: path8,
   pathParams,
   responseClasses,
   methodParams,
@@ -1049,14 +1055,14 @@ var templateQueryMethod = ({
   description,
   deprecated
 }) => {
-  const isPostFetch = httpMethod === "post" && (POST_FETCH_INCLUDES_PATH.some((p) => path7.includes(p)) || path7.endsWith("/list"));
+  const isPostFetch = httpMethod === "post" && (POST_FETCH_INCLUDES_PATH.some((p) => path8.includes(p)) || path8.endsWith("/list"));
   const isFetch = classMethod.startsWith("fetch");
   const isGet = httpMethod === "get" || isPostFetch || isFetch;
   const queryMethod = isGet ? "useQuery" : "useMutation";
   let mParams = "";
   let mParamsNoTypes = "";
-  let newPath = `'${path7}'`;
-  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path7);
+  let newPath = `'${path8}'`;
+  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path8);
   for (const pathParam of sortedPathParams) {
     const type = ParserUtils.parseType(pathParam);
     if (pathParam.name !== "namespace") {
@@ -1064,7 +1070,7 @@ var templateQueryMethod = ({
       mParamsNoTypes += pathParam.name + ", ";
     }
     const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
-    if (path7.match(`{${pathParam.name}}`)) {
+    if (path8.match(`{${pathParam.name}}`)) {
       if (type === "string") {
         newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
       } else {
@@ -1203,7 +1209,7 @@ import { ${serviceNameTitle} } from '@accelbyte/sdk-${serviceNameTitle.toLowerCa
 
 const sdk = AccelByte.SDK({
   coreConfig: {
-    baseURL: 'https://demo.accelbyte.io',
+    baseURL: '__DOMAIN__',
     clientId: '77f88506b6174c3ea4d925f5b4096ce8',
     namespace: 'accelbyte',
     redirectURI: 'http://localhost:3030'
@@ -1233,7 +1239,7 @@ var normalizeMethodSnippet = (methodInput, splitWord) => {
 };
 
 // src/helpers/SwaggerReaderHelpers.ts
-var GIT_URL = "https://github.com/AccelByte/accelbyte-web-sdk/blob/main/packages";
+var GIT_URL = "https://github.com/AccelByte/accelbyte-typescript-sdk/blob/main/packages";
 var SwaggerReaderHelpers = class _SwaggerReaderHelpers {
   static getServicePrefix = (servicePaths) => servicePaths[servicePaths.length - 1].split("/")[1];
   static parseAllEndpoints = async ({
@@ -1280,11 +1286,11 @@ var SwaggerReaderHelpers = class _SwaggerReaderHelpers {
       admin: {},
       public: {}
     };
-    for (const [path7, operation] of sortedPathsByLength) {
-      if (path7.indexOf("/healthz") >= 0) {
+    for (const [path8, operation] of sortedPathsByLength) {
+      if (path8.indexOf("/healthz") >= 0) {
         continue;
       }
-      const isAdminEndpoint = path7.indexOf("/admin/") > -1;
+      const isAdminEndpoint = path8.indexOf("/admin/") > -1;
       const picked = isAdminEndpoint ? result.admin : result.public;
       const {
         arrayDefinitions,
@@ -1302,25 +1308,25 @@ var SwaggerReaderHelpers = class _SwaggerReaderHelpers {
       const httpMethods = Object.keys(operation);
       for (const httpMethod of httpMethods) {
         const endpoint = await Endpoint.parseAsync(operation[httpMethod]).catch((error) => {
-          console.error(JSON.stringify({ path: path7, httpMethod }, null, 2));
+          console.error(JSON.stringify({ path: path8, httpMethod }, null, 2));
           throw error;
         });
         if (!endpoint.tags) continue;
         const [tag] = endpoint.tags;
-        const pathWithBase = `${api.basePath ?? ""}${path7}`;
+        const pathWithBase = `${api.basePath ?? ""}${path8}`;
         const permissionType = getPermissionType(getPermission(endpoint));
         tagToClassMethodsMapByType[tag] = tagToClassMethodsMapByType[tag] ? tagToClassMethodsMapByType[tag] : {};
         const isForm = endpoint.consumes && endpoint.consumes[0] === "application/x-www-form-urlencoded";
         const classMethod = ParserUtils.generateNaturalLangMethod({
           servicePrefix,
-          path: path7,
+          path: path8,
           httpMethod,
           isForm,
           existingMethods: tagToClassMethodsMapByType[tag],
           permissionType
         });
-        tagToClassMethodsMapByType[tag][classMethod] = `${path7} ${httpMethod}`;
-        generatedMethods[`${path7} ${httpMethod}`] = `${classMethod}`;
+        tagToClassMethodsMapByType[tag][classMethod] = `${path8} ${httpMethod}`;
+        generatedMethods[`${path8} ${httpMethod}`] = `${classMethod}`;
         if (!snippetMap[pathWithBase]) {
           snippetMap[pathWithBase] = {};
         }
@@ -1419,7 +1425,7 @@ var SwaggerReaderHelpers = class _SwaggerReaderHelpers {
 };
 
 // src/templates/template-api-index.ts
-var templateApiIndex = (serviceNameTitle, apiList) => {
+var templateApiIndex = (serviceNameTitle, apiList, isGenerateWebSocket = false) => {
   let imports = "";
   let returnStatement = "";
   for (const cl of apiList) {
@@ -1428,6 +1434,12 @@ var templateApiIndex = (serviceNameTitle, apiList) => {
 import { ${cl} } from './${dir}/${cl}.js'`;
     returnStatement += `
 ${cl}, `;
+  }
+  if (isGenerateWebSocket) {
+    imports += `
+import { WebSocketClass } from './generated-websocket/WebSocketClass.js'`;
+    returnStatement += `
+WebSocket: WebSocketClass, `;
   }
   return `/**
  * AUTO GENERATED
@@ -1733,7 +1745,9 @@ var CodeGenerator = class _CodeGenerator {
     const queryImportsSet = /* @__PURE__ */ new Set();
     const apiInfo = { ...api.info, "x-version": api["x-version"]?.version };
     console.log("----------\nGenerating API:", { title: apiInfo.title, version: apiInfo.version });
-    ParserUtils.writeXVersion(_CodeGenerator.srcFolder(), api["x-version"], api.info);
+    if (!CliParser.isGenerateSnippetOnly()) {
+      ParserUtils.writeXVersion(_CodeGenerator.srcFolder(), api["x-version"], api.info);
+    }
     const parsedInformation = await SwaggerReaderHelpers.parseAllEndpoints({ api, sdkName, serviceName });
     if (CliParser.getSnippetOutputPath()) {
       try {
@@ -1848,7 +1862,8 @@ var CodeGenerator = class _CodeGenerator {
     };
     generatePublicOrAdmin(true);
     generatePublicOrAdmin(false);
-    const apiIndexBuff = templateApiIndex(serviceNameTitle, mainApiList);
+    const isGenerateWebSocket = CliParser.isGenerateWebSocket();
+    const apiIndexBuff = templateApiIndex(serviceNameTitle, mainApiList, isGenerateWebSocket);
     ParserUtils.writeApiMainFile(_CodeGenerator.srcFolder(), serviceNameTitle, apiIndexBuff);
     console.log("\nCOMPLETED\n----------\n\n");
     return { indexImports: indexImportsSet, queryImports: queryImportsSet };
@@ -1919,25 +1934,373 @@ var SwaggerDownloader = class _SwaggerDownloader {
   };
 };
 
+// src/WebsocketGenerator.ts
+import fs6 from "fs";
+import path6 from "path";
+
+// src/templates/template-ws-class.ts
+var definitionToFunctionName = (type) => {
+  if (type.endsWith("Request")) {
+    return "send" + capitalize(type.slice(0, type.length - 7));
+  }
+  return type;
+};
+var renderSendFunction = (name, definition) => {
+  const functionName = definitionToFunctionName(name);
+  return `const ${functionName} = (data: Omit<Definitions.${capitalize(name)}, 'type'>) => {
+    send({ type: '${name}', ...data })
+  }`;
+};
+var templateWebsocketClass = (name, path8, definitions) => {
+  const requestDefinitions = Object.keys(definitions).filter((key) => {
+    const val = definitions[key];
+    return val["x-type"] == "request";
+  }).map((key) => [key, definitions[key]]);
+  return `/* eslint-disable camelcase */
+/* eslint-disable  no-inner-declarations */
+// @ts-ignore -> ts-expect-error TS6133
+import { AccelByteSDK, RefreshToken, SdkSetConfigParam } from '@accelbyte/sdk'
+import * as Definitions from './WebSocketDefinitions'
+
+const messageParser = (data: string) => {
+  const toVal = (str?: string) => {
+    if (str) {
+      if (str.startsWith('[') && str.endsWith(']')) {
+        return str
+          .slice(1, str.length - 1)
+          .split(',')
+          .filter(v => v !== '')
+      }
+    }
+    return str
+  }
+
+  const entries = data.split('\\n')
+    .filter(line => line !== '')
+    .map(line => {
+      const [key, valStr] = line.split(': ')
+      return [key, toVal(valStr)]
+    })
+
+  return Object.fromEntries(entries)
+}
+
+const messageSerializer = (data: Record<string, any>) => {
+  return Object.keys(data)
+    .map(key => {
+      const toStr = (val: any) => {
+        // array
+        if (Array.isArray(val)) {
+          return \`[\${String(val)}]\`
+        }
+        // null, undefined
+        if (!val) {
+          return ''
+        }
+        return String(val)
+      }
+      const val = data[key]
+      const valStr = toStr(val)
+
+      return \`\${key}: \${valStr}\`
+    })
+    .join('\\n')
+}
+
+export function WebSocketClass(sdk: AccelByteSDK, args?: SdkSetConfigParam) {
+  const sdkAssembly = sdk.assembly()
+  const baseURL = (args?.coreConfig?.baseURL ?? sdkAssembly.coreConfig.baseURL).replace('http', 'ws')
+  const path = '${path8}'
+  const url = baseURL + path
+  let ws: WebSocket | null = null
+  let isDisconnectManually = false
+  const allowReconnect = sdkAssembly.webSocketConfig.allowReconnect ?? true
+  const maxReconnectAttempts = sdkAssembly.webSocketConfig.maxReconnectAttempts ?? 0
+  let reconnectAttempts = maxReconnectAttempts
+
+  const connect = () => {
+    const token = sdk.getToken()
+
+    if (!token.accessToken) {
+      console.warn('No access token, please login first')
+      return
+    }
+
+    if (!ws) {
+      ws = new WebSocket(url, token.accessToken)
+    }
+  }
+
+  const refreshToken = async () => {
+    const { refreshToken } = sdk.getToken()
+    if (refreshToken) {
+      const refresh = new RefreshToken({
+        config: {
+          axiosConfig: sdkAssembly.axiosConfig.request,
+          clientId: sdkAssembly.coreConfig.clientId,
+          refreshToken
+        }
+      })
+      const result = await refresh.runWithLock()
+      if (result) {
+        sdk.setToken({
+          accessToken: result.access_token,
+          refreshToken: result.refresh_token
+        })
+        return true
+      }
+    }
+    return false
+  }
+
+  const handleReconnect = async (ev: CloseEvent) => {
+    if (!allowReconnect || isDisconnectManually || !sdk.getToken().accessToken) return
+    // token revoked
+    if (ev.code === 4020) {
+      await refreshToken()
+      reconnectAttempts--
+      connect()
+    } else if (ev.code >= 1001 && ev.code <= 2999) {
+      // Only reconnect if codes in range 1001-2999
+      if (!ws || ws.readyState !== ws.OPEN) return
+
+      if (maxReconnectAttempts === 0) {
+        setTimeout(() => {
+          connect()
+        }, 1000)
+      } else if (reconnectAttempts !== 0) {
+        setTimeout(() => {
+          reconnectAttempts--
+          connect()
+        }, 1000)
+      }
+    }
+  }
+
+  const disconnect = (code?: number, reason?: string) => {
+    if (ws) {
+      ws.close(code, reason)
+      isDisconnectManually = true
+      ws = null
+    }
+  }
+
+  const send = (message: Definitions.WebSocketRequest) => {
+    if (ws) {
+      ws.send(messageSerializer(message))
+    }
+  }
+
+  const sendRaw = (rawMessage: string) => {
+    if (ws) {
+      ws.send(rawMessage)
+    }
+  }
+
+  const onOpen = (cb: () => any) => {
+    if (ws) {
+      function listener(this: WebSocket, _ev: Event) {
+        isDisconnectManually = false
+        reconnectAttempts = maxReconnectAttempts
+        cb()
+      }
+      ws.addEventListener('open', listener)
+      return {
+        removeEventListener: () => ws?.removeEventListener('open', listener)
+      }
+    }
+    return {}
+  }
+
+  const onClose = (cb: (ev: CloseEvent) => any) => {
+    if (ws) {
+      function listener(this: WebSocket, ev: CloseEvent) {
+        handleReconnect(ev)
+        cb(ev)
+      }
+      ws.addEventListener('close', listener)
+      return {
+        removeEventListener: () => ws?.removeEventListener('close', listener)
+      }
+    }
+    return {}
+  }
+
+  const onMessage = (cb: (message: Definitions.WebSocketResponseOrNotification | string) => any, raw: boolean = false) => {
+    if (ws) {
+      function listener(this: WebSocket, ev: MessageEvent<any>) {
+        if (raw) {
+          cb(ev.data)
+        } else {
+          const result = Definitions.WebSocketResponseOrNotification.parse(messageParser(ev.data))
+          cb(result)
+        }
+      }
+      ws.addEventListener('message', listener)
+      return {
+        removeEventListener: () => ws?.removeEventListener('message', listener)
+      }
+    }
+    return {}
+  }
+
+  const onError = (cb: (err: any) => any) => {
+    if (ws) {
+      function listener(this: WebSocket, err: any) {
+        cb(err)
+      }
+      ws.addEventListener('error', listener)
+      return {
+        removeEventListener: () => ws?.removeEventListener('error', listener)
+      }
+    }
+    return {}
+  }
+
+  ${requestDefinitions.map(([name2, definition]) => renderSendFunction(name2, definition)).join(`
+
+  `)}
+
+  return {
+    instance: ws,
+    connect,
+    disconnect,
+    send,
+    sendRaw,
+    onOpen,
+    onClose,
+    onMessage,
+    onError,
+    ${requestDefinitions.map(([name2, _2]) => definitionToFunctionName(name2)).join(",\n    ")}
+  }
+}
+
+`;
+};
+
+// src/templates/template-ws-defintions.ts
+var renderZod = (property) => {
+  switch (property.type) {
+    case "string":
+      return `z.coerce.string()`;
+    case "integer":
+      return `z.coerce.number()`;
+    case "boolean":
+      return `z.boolean()`;
+    case "array":
+      return `z.array(${renderZod(property.items)})`;
+    default:
+      return `z.any()`;
+  }
+};
+var renderProperty = (name, type, property, required) => {
+  const isRequired = required && required.includes(name);
+  return `${name}: ${renderZod(property)}${isRequired || type != "request" ? "" : ".optional()"}`;
+};
+var renderDefinition = (name, definition) => {
+  const capitalizedName = capitalize(name);
+  if (definition.properties) {
+    const properties = Object.entries(definition.properties);
+    return `export const ${capitalizedName} = z.object({
+  type: z.literal("${name}"),
+  ${properties.map(([name2, property]) => renderProperty(name2, definition["x-type"], property, definition.required)).join(",\n  ")}
+})
+
+export type ${capitalizedName} = z.infer<typeof ${capitalizedName}>
+`;
+  }
+  return "";
+};
+var renderAllDefinitions = (definitions) => {
+  if (definitions) {
+    const definitionEntries = Object.entries(definitions);
+    return definitionEntries.map(([name, definition]) => renderDefinition(name, definition)).join("\n\n");
+  }
+  return "";
+};
+var renderUnion = (type, definitions) => {
+  if (definitions) {
+    let capitalizedType = "";
+    if (typeof type === "string") {
+      capitalizedType = capitalize(type);
+    } else {
+      capitalizedType = type.map((t) => capitalize(t)).join("Or");
+    }
+    const filteredDefinitions = Object.entries(definitions).filter(([_2, def]) => {
+      if (typeof type === "string") {
+        return def["x-type"] === type;
+      } else {
+        return type.includes(def["x-type"]);
+      }
+    }).map(([name, _2]) => capitalize(name));
+    return `export const WebSocket${capitalizedType} = z.discriminatedUnion("type", [
+  ${filteredDefinitions.join(",\n  ")}
+])
+  
+export type WebSocket${capitalizedType} = z.infer<typeof WebSocket${capitalizedType}>`;
+  }
+  return "";
+};
+var templateWebsocketDefinitions = (definitions) => {
+  return `/**
+ * AUTO GENERATED
+ */
+
+import { z } from 'zod'
+
+${renderAllDefinitions(definitions)}
+
+${renderUnion("request", definitions)}
+
+${renderUnion(["response", "notification"], definitions)}
+`;
+};
+
+// src/WebsocketGenerator.ts
+var WebsocketGenerator = class {
+  static srcFolder = () => CliParser.getOutputPath();
+  static outputFolder = () => path6.join(this.srcFolder(), "generated-websocket");
+  static schemaContent = () => {
+    const fileContent = JSON.parse(fs6.readFileSync(CliParser.getWebSocketSchemaPath(), "utf8"));
+    return fileContent;
+  };
+  static prepareDirs = () => {
+    ParserUtils.mkdirIfNotExist(this.outputFolder());
+  };
+  static main = () => {
+    const { name, path: wsPath, definitions } = this.schemaContent();
+    const templateDefinitions = templateWebsocketDefinitions(definitions);
+    this.prepareDirs();
+    const filePath = path6.join(this.outputFolder(), "WebSocketDefinitions.ts");
+    fs6.writeFileSync(filePath, templateDefinitions, "utf8");
+    const templateClass2 = templateWebsocketClass(name, wsPath, definitions);
+    const filePathClass = path6.join(this.outputFolder(), "WebSocketClass.ts");
+    fs6.writeFileSync(filePathClass, templateClass2, "utf8");
+  };
+};
+
 // src/cli.ts
 var generateSdk = async () => {
   const arrayOfSets = await Promise.all(CliParser.getConfigFile().map((config) => CodeGenerator.main(config)));
   if (CliParser.isGenerateSnippetOnly()) {
     return;
   }
+  if (CliParser.isGenerateWebSocket()) {
+    WebsocketGenerator.main();
+  }
   const indexImportsSet = /* @__PURE__ */ new Set();
   const queryImportsSet = /* @__PURE__ */ new Set();
   const filenamesSet = /* @__PURE__ */ new Set();
   for (const set of arrayOfSets) {
     set.indexImports.forEach((value) => {
-      const fileName = path6.basename(value);
+      const fileName = path7.basename(value);
       if (!filenamesSet.has(fileName)) {
         indexImportsSet.add(value);
         filenamesSet.add(fileName);
       }
     });
     set.queryImports.forEach((value) => {
-      const fileName = path6.basename(value);
+      const fileName = path7.basename(value);
       if (!filenamesSet.has(fileName)) {
         queryImportsSet.add(value);
       }
@@ -1958,30 +2321,39 @@ yargs.command("download-swaggers", "Download swaggers JSON files", (yargs2) => {
   CliParser.createInstance(yargs2);
   SwaggerDownloader.main();
 }).command("generate-code", "Generate code based on downloaded swagger files", async (yargs2) => {
-  yargs2.check(({ output }) => {
-    if (!output?.trim()) {
+  yargs2.check(({ output, snippetOnly, snippetOutput }) => {
+    if (!output?.trim() && !snippetOnly) {
       throw new Error("output is required for generate-code");
     }
+    if (snippetOnly && !snippetOutput) {
+      throw new Error("snippetOutput is required when generating snippets.");
+    }
     return true;
   });
   CliParser.createInstance(yargs2);
   await generateSdk();
 }).option("config", {
-  description: "Config file providing backend services URL.",
+  description: "Path to the config file with backend service URLs.",
   type: "string",
   demandOption: true
 }).option("swaggersOutput", {
-  description: "Output path for downloaded swaggers JSON files.",
+  description: "Directory to save the downloaded Swagger JSON files.",
   type: "string",
   demandOption: true
 }).option("output", {
-  description: "Output path for generated code. Required for generate-code",
+  description: "Directory for the generated code. Required when using the generate-code command.",
   type: "string"
 }).option("skipReactQuery", {
-  description: "Skip generating react query",
+  description: "Disable React Query code generation.",
   type: "boolean"
 }).option("snippetOnly", {
-  description: "Only generate snippet",
+  description: "Generate only code snippets.",
   type: "boolean"
+}).option("snippetOutput", {
+  description: "Directory for the generated code snippets. Required when generating snippets.",
+  type: "string"
+}).option("webSocketSchema", {
+  description: "Path to the WebSocket schema file (schema.json). If provided, WebSocket methods will be generated based on the schema.",
+  type: "string"
 }).demandCommand(1).help().argv;
 //# sourceMappingURL=accelbyte-codegen.mjs.map