@polytric/openws-sdkgen 0.0.4 → 0.0.6

package/dist/plans/typescript.js

@@ -0,0 +1,532 @@
+// src/plans/typescript.ts
+import path from "path";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var TEMPLATE_DIR = path.join(__dirname, "../templates/typescript");
+var SRC_TEMPLATE_DIR = path.join(TEMPLATE_DIR, "src");
+var CORE_TEMPLATE_DIR = path.join(SRC_TEMPLATE_DIR, "core");
+var ROLES_TEMPLATE_DIR = path.join(CORE_TEMPLATE_DIR, "roles");
+var MODELS_TEMPLATE_DIR = path.join(CORE_TEMPLATE_DIR, "models");
+var SDK_TEMPLATE_DIR = path.join(SRC_TEMPLATE_DIR, "sdk");
+function pascalCase(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function camelCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function kebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+function createPlan(ctx) {
+  const { ir, request, spec } = ctx;
+  if (!ir) throw new Error("ir is required");
+  if (!request) throw new Error("request is required");
+  if (!spec) throw new Error("spec is required");
+  const language = Object.keys(request.target)[0];
+  const isTypeScript = language === "typescript";
+  const extension = isTypeScript ? "ts" : "js";
+  const packageName = `@${kebabCase(ir.package.project)}/${kebabCase(ir.package.service)}-openws-sdk`;
+  const plan = [
+    {
+      name: `${language} package manifest`,
+      command: "render",
+      getData: () => ({
+        isTypeScript,
+        packageName,
+        description: ir.package.description,
+        version: ir.package.version ?? "0.0.0",
+        extension
+      }),
+      template: path.join(TEMPLATE_DIR, "package.json.ejs"),
+      output: path.join(request.outputPath, "package.json")
+    }
+  ];
+  if (isTypeScript) {
+    plan.push(
+      {
+        name: `${language} tsconfig`,
+        command: "render",
+        getData: () => ({}),
+        template: path.join(TEMPLATE_DIR, "tsconfig.json.ejs"),
+        output: path.join(request.outputPath, "tsconfig.json")
+      },
+      {
+        name: `${language} tsup config`,
+        command: "render",
+        getData: () => ({}),
+        template: path.join(TEMPLATE_DIR, "tsup.config.ts.ejs"),
+        output: path.join(request.outputPath, "tsup.config.ts")
+      }
+    );
+  }
+  const networkExports = [];
+  for (const [networkName, networkSpec] of Object.entries(spec.networks)) {
+    const networkFileName = kebabCase(networkName);
+    const networkOutputPath = path.join(request.outputPath, "src", networkFileName);
+    const sdkOutputPath = path.join(request.outputPath, "src", "sdk");
+    const allRoles = Object.values(networkSpec.roles).map(toRoleInfo);
+    const rolesByName = new Map(allRoles.map((role) => [role.roleName, role]));
+    const hostRoles = allRoles;
+    const modelScopes = buildModelScopes(buildSpecModels(networkSpec));
+    networkExports.push({
+      exportName: camelCase(networkName),
+      fileName: networkFileName
+    });
+    plan.push({
+      name: `${language} network ${networkName}`,
+      command: "render",
+      getData: () => ({
+        isTypeScript,
+        networkName,
+        networkClassName: `${pascalCase(networkName)}Network`,
+        description: networkSpec.description,
+        version: networkSpec.version,
+        hostRoles,
+        allRoles,
+        extension
+      }),
+      template: path.join(CORE_TEMPLATE_DIR, "network.ts.ejs"),
+      output: path.join(networkOutputPath, `network.${extension}`)
+    });
+    plan.push({
+      name: `${language} network exports ${networkName}`,
+      command: "render",
+      getData: () => ({
+        isTypeScript,
+        extension,
+        modelScopes
+      }),
+      template: path.join(CORE_TEMPLATE_DIR, "index.ts.ejs"),
+      output: path.join(networkOutputPath, `index.${extension}`)
+    });
+    const roleMessagesByName = /* @__PURE__ */ new Map();
+    for (const role of allRoles) {
+      const roleSpec = networkSpec.roles[role.roleName];
+      const messages = Object.entries(roleSpec.messages).map(
+        ([messageName, messageSpec]) => toMessageInfo(messageName, messageSpec, rolesByName)
+      );
+      roleMessagesByName.set(role.roleName, messages);
+    }
+    const rolesWithMessages = allRoles.map((role) => ({
+      ...role,
+      messages: roleMessagesByName.get(role.roleName) ?? []
+    }));
+    for (const role of rolesWithMessages) {
+      plan.push({
+        name: `${language} core role ${role.className}`,
+        command: "render",
+        getData: () => ({
+          isTypeScript,
+          extension,
+          peerRoles: allRoles.filter((peerRole) => peerRole.roleName !== role.roleName),
+          ...role
+        }),
+        template: path.join(ROLES_TEMPLATE_DIR, "role.ts.ejs"),
+        output: path.join(networkOutputPath, "roles", `${role.fileName}.${extension}`)
+      });
+    }
+    plan.push({
+      name: `${language} core role exports ${networkName}`,
+      command: "render",
+      getData: () => ({
+        isTypeScript,
+        extension,
+        roles: allRoles
+      }),
+      template: path.join(ROLES_TEMPLATE_DIR, "index.ts.ejs"),
+      output: path.join(networkOutputPath, "roles", `index.${extension}`)
+    });
+    for (const modelScope of modelScopes) {
+      plan.push({
+        name: `${language} model exports ${modelScope.scopeName}`,
+        command: "render",
+        getData: () => ({
+          isTypeScript,
+          extension,
+          ...modelScope
+        }),
+        template: path.join(MODELS_TEMPLATE_DIR, "index.ts.ejs"),
+        output: path.join(
+          networkOutputPath,
+          "models",
+          modelScope.fileName,
+          `index.${extension}`
+        )
+      });
+      for (const model of modelScope.models) {
+        plan.push({
+          name: `${language} model ${model.className}`,
+          command: "render",
+          getData: () => ({
+            isTypeScript,
+            ...model
+          }),
+          template: path.join(MODELS_TEMPLATE_DIR, "model.ts.ejs"),
+          output: path.join(
+            networkOutputPath,
+            "models",
+            modelScope.fileName,
+            `${model.fileName}.${extension}`
+          )
+        });
+      }
+    }
+    for (const hostRole of hostRoles) {
+      const remoteRoles = getPeerRoles(networkSpec, rolesByName, hostRole.roleName).map(
+        (remoteRole) => ({
+          ...remoteRole,
+          scopedApiName: `${hostRole.className}${remoteRole.className}Api`,
+          allowedMethodNames: getAllowedMessageMethodNames(
+            networkSpec,
+            remoteRole.roleName,
+            hostRole.roleName
+          )
+        })
+      );
+      const roleSpec = networkSpec.roles[hostRole.roleName];
+      const roleHandlers = Object.entries(roleSpec.messages).map(
+        ([messageName, messageSpec]) => toHandlerInfo(
+          messageName,
+          messageSpec,
+          rolesByName,
+          hostRole.roleName,
+          allRoles
+        )
+      );
+      plan.push({
+        name: `${language} sdk role ${hostRole.className}`,
+        command: "render",
+        getData: () => ({
+          isTypeScript,
+          extension,
+          handlers: roleHandlers,
+          networkName,
+          networkDescription: networkSpec.description,
+          networkVersion: networkSpec.version,
+          remoteRoles,
+          ...hostRole
+        }),
+        template: path.join(SDK_TEMPLATE_DIR, "role.ts.ejs"),
+        output: path.join(sdkOutputPath, `${hostRole.fileName}.${extension}`)
+      });
+    }
+    plan.push({
+      name: `${language} sdk exports ${networkName}`,
+      command: "render",
+      getData: () => ({
+        isTypeScript,
+        extension,
+        roles: hostRoles
+      }),
+      template: path.join(SDK_TEMPLATE_DIR, "index.ts.ejs"),
+      output: path.join(sdkOutputPath, `index.${extension}`)
+    });
+  }
+  plan.push({
+    name: `${language} package exports`,
+    command: "render",
+    getData: () => ({
+      isTypeScript,
+      extension,
+      networkExports
+    }),
+    template: path.join(SRC_TEMPLATE_DIR, "index.ts.ejs"),
+    output: path.join(request.outputPath, "src", `index.${extension}`)
+  });
+  return {
+    ...ctx,
+    plan
+  };
+}
+function buildModelScopes(models) {
+  const scopes = /* @__PURE__ */ new Map();
+  const objectModels = models.filter((model) => model.type === "object");
+  for (const model of objectModels) {
+    const scopeName = model.scopeName;
+    const scope = scopes.get(scopeName) ?? {
+      scopeName,
+      className: pascalCase(scopeName),
+      varName: camelCase(scopeName),
+      fileName: kebabCase(scopeName),
+      models: []
+    };
+    scope.models.push({
+      scopeName,
+      className: pascalCase(model.modelName),
+      fileName: kebabCase(model.modelName),
+      schema: buildModelSchema(model, objectModels),
+      properties: (model.properties ?? []).map((property) => ({
+        name: property.modelName,
+        optional: !property.required,
+        typeName: mapType(property)
+      })),
+      imports: buildModelImports(model)
+    });
+    scopes.set(scopeName, scope);
+  }
+  return [...scopes.values()];
+}
+function toRoleInfo(role) {
+  const className = pascalCase(role.name);
+  const fileName = kebabCase(role.name);
+  return {
+    roleName: role.name,
+    className,
+    roleClassName: className,
+    hostRoleClassName: `${className}Host`,
+    apiName: `${className}Api`,
+    varName: camelCase(role.name),
+    apiVarName: `${camelCase(role.name)}Api`,
+    fileName,
+    roleFileName: `${fileName}-role`,
+    description: role.description || "",
+    endpoints: role.endpoints || []
+  };
+}
+function getMessageFromRoles(message, rolesByName, currentRoleName, allRoles) {
+  const fromRoleNames = getMessageFromRoleNames(
+    message,
+    currentRoleName,
+    allRoles.map((role) => role.roleName)
+  );
+  return fromRoleNames.map((roleName) => rolesByName.get(roleName)).filter((role) => Boolean(role));
+}
+function getExplicitMessageFromRoles(message, rolesByName) {
+  if (!message.from) return void 0;
+  return message.from.map((roleName) => rolesByName.get(roleName)).filter((role) => Boolean(role));
+}
+function getPeerRoles(network, rolesByName, hostRoleName) {
+  const peers = /* @__PURE__ */ new Set();
+  const hostRole = network.roles[hostRoleName];
+  const allRoleNames = Object.keys(network.roles);
+  for (const message of Object.values(hostRole.messages)) {
+    for (const roleName of getMessageFromRoleNames(message, hostRoleName, allRoleNames)) {
+      peers.add(roleName);
+    }
+  }
+  for (const [roleName, role] of Object.entries(network.roles)) {
+    if (roleName === hostRoleName) continue;
+    for (const message of Object.values(role.messages)) {
+      if (getMessageFromRoleNames(message, roleName, allRoleNames).includes(hostRoleName)) {
+        peers.add(roleName);
+      }
+    }
+  }
+  return [...peers].map((roleName) => rolesByName.get(roleName)).filter((role) => Boolean(role));
+}
+function getMessageFromRoleNames(message, targetRoleName, allRoleNames) {
+  return message.from ?? allRoleNames.filter((roleName) => roleName !== targetRoleName);
+}
+function getAllowedMessageMethodNames(network, targetRoleName, fromRoleName) {
+  const targetRole = network.roles[targetRoleName];
+  const allRoleNames = Object.keys(network.roles);
+  return Object.entries(targetRole.messages).filter(
+    ([, message]) => getMessageFromRoleNames(message, targetRoleName, allRoleNames).includes(fromRoleName)
+  ).map(([messageName]) => camelCase(messageName));
+}
+function buildSpecModels(network) {
+  const models = [];
+  for (const role of Object.values(network.roles)) {
+    for (const [messageName, message] of Object.entries(role.messages)) {
+      models.push(...buildIrModels(role.name, `${messageName}Payload`, message.payload));
+    }
+  }
+  return models;
+}
+function buildIrModels(scopeName, modelName, schema) {
+  const type = schema.type;
+  const model = {
+    type,
+    scopeName,
+    modelName,
+    description: schema.description
+  };
+  switch (type) {
+    case "string":
+    case "number":
+    case "integer":
+    case "boolean":
+    case "null":
+      return [];
+    case "array": {
+      const items = schema.items;
+      if (!items) return [];
+      return buildIrModels(scopeName, modelName, items);
+    }
+    case "object": {
+      const properties = [];
+      model.properties = properties;
+      const models = [];
+      const schemaProperties = schema.properties;
+      if (!schemaProperties) return [model];
+      for (const [subName, subSchema] of Object.entries(schemaProperties)) {
+        const subModels = buildIrModels(scopeName, subName, subSchema);
+        const mainModel = subModels.find((m) => m.modelName === subName) ?? subSchema;
+        const property = {
+          type: mainModel.type,
+          description: mainModel.description,
+          scopeName: mainModel.scopeName ?? scopeName,
+          modelName: mainModel.modelName ?? subName,
+          required: schema.required?.includes(subName)
+        };
+        const itemsSource = mainModel.properties?.[0]?.items ?? mainModel.items;
+        if (itemsSource) {
+          property.items = {
+            type: itemsSource.type,
+            description: itemsSource.description,
+            scopeName: itemsSource?.scopeName ?? scopeName,
+            modelName: itemsSource?.modelName ?? subName
+          };
+        }
+        properties.push(property);
+        models.push(...subModels);
+      }
+      return [model, ...models];
+    }
+    default:
+      return [];
+  }
+}
+function buildModelImports(model) {
+  const imports = /* @__PURE__ */ new Map();
+  const addImport = (modelName) => {
+    if (!modelName || modelName === model.modelName) return;
+    const className = pascalCase(modelName);
+    imports.set(className, {
+      className,
+      fileName: kebabCase(modelName)
+    });
+  };
+  for (const property of model.properties ?? []) {
+    if (property.type === "object") {
+      addImport(property.modelName);
+    }
+    if (property.type === "array" && property.items?.type === "object") {
+      addImport(property.items.modelName);
+    }
+  }
+  return [...imports.values()];
+}
+function buildModelSchema(model, models, seen = /* @__PURE__ */ new Set()) {
+  const key = `${model.scopeName}:${model.modelName}`;
+  if (seen.has(key)) return { type: "object" };
+  const nextSeen = new Set(seen);
+  nextSeen.add(key);
+  const properties = {};
+  const required = [];
+  for (const property of model.properties ?? []) {
+    properties[property.modelName] = buildPropertySchema(property, models, nextSeen);
+    if (property.required) required.push(property.modelName);
+  }
+  const schema = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    type: "object",
+    properties,
+    additionalProperties: false
+  };
+  if (model.description) schema.description = model.description;
+  if (required.length > 0) schema.required = required;
+  return schema;
+}
+function buildNestedObjectSchema(model, models, seen) {
+  const { $schema: _schema, ...schema } = buildModelSchema(model, models, seen);
+  return schema;
+}
+function buildPropertySchema(property, models, seen) {
+  const schema = buildSchemaForType(
+    property.type,
+    property.scopeName,
+    property.modelName,
+    models,
+    seen
+  );
+  if (property.description) schema.description = property.description;
+  if (property.type === "array" && property.items) {
+    schema.items = buildSchemaForType(
+      property.items.type,
+      property.items.scopeName,
+      property.items.modelName,
+      models,
+      seen
+    );
+    if (property.items.description && typeof schema.items === "object" && schema.items !== null) {
+      const itemSchema = schema.items;
+      itemSchema.description = property.items.description;
+    }
+  }
+  return schema;
+}
+function buildSchemaForType(type, scopeName, modelName, models, seen) {
+  switch (type) {
+    case "string":
+    case "number":
+    case "integer":
+    case "boolean":
+    case "null":
+      return { type };
+    case "array":
+      return { type: "array" };
+    case "object": {
+      const model = findModel(models, scopeName, modelName);
+      if (!model) return { type: "object" };
+      return buildNestedObjectSchema(model, models, seen);
+    }
+    default:
+      return {};
+  }
+}
+function findModel(models, scopeName, modelName) {
+  return models.find((model) => model.scopeName === scopeName && model.modelName === modelName);
+}
+function toHandlerInfo(messageName, message, rolesByName, _currentRoleName, _allRoles) {
+  const payloadType = pascalCase(messageName) + "Payload";
+  const methodSuffix = pascalCase(messageName);
+  return {
+    dispatchMethodName: camelCase(messageName),
+    onMethodName: `on${methodSuffix}`,
+    listenerFieldName: `${camelCase(messageName)}Handlers`,
+    messageName,
+    payloadType,
+    payloadFileName: kebabCase(payloadType),
+    schema: toJsonValue(message.payload),
+    fromRoles: getExplicitMessageFromRoles(message, rolesByName),
+    bindFromRoles: getMessageFromRoles(message, rolesByName, _currentRoleName, _allRoles)
+  };
+}
+function toMessageInfo(messageName, message, rolesByName) {
+  const payloadType = pascalCase(messageName) + "Payload";
+  return {
+    methodName: camelCase(messageName),
+    messageName,
+    payloadType,
+    payloadFileName: kebabCase(payloadType),
+    schema: toJsonValue(message.payload),
+    fromRoles: getExplicitMessageFromRoles(message, rolesByName)
+  };
+}
+function toJsonValue(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function mapType(property) {
+  switch (property.type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "array":
+      if (!property.items) return "unknown[]";
+      return `${mapType(property.items)}[]`;
+    case "object":
+      return pascalCase(property.modelName);
+    default:
+      return "unknown";
+  }
+}
+export {
+  createPlan as default
+};

package/dist/templates/dotnet/HostRole.cs.ejs

@@ -1,3 +1,4 @@
+using System;
 using System.Threading.Tasks;
 using Newtonsoft.Json.Linq;
 using Polytric.OpenWs.Core;
@@ -9,24 +10,24 @@ namespace <%= ctx.namespace %>
 {
     public partial class <%= ctx.className %> : <%= ctx.baseClassName %>
     {
-        public override string Name { get; set; } = "<%= ctx.roleName %>";
-        public override string Description { get; set; } = "<%= ctx.description ?? '' %>";
+        public string Name => "<%= ctx.roleName %>";
+        public string Description => "<%= ctx.description ?? '' %>";
 
-        public override async Task HandleOpenAsync(RemoteRole remoteRole)
+        public override void HandleOpen(RemoteRole remoteRole)
         {
 <% for (const remoteRole of ctx.remoteRoles) { %>
             if (remoteRole is <%= remoteRole.className %> <%= remoteRole.varName %>)
             {
-                await HandleOpenAsync(<%= remoteRole.varName %>).ConfigureAwait(false);
+                HandleOpen(<%= remoteRole.varName %>);
             }
 <% } -%>
         }
 
 <% for (const remoteRole of ctx.remoteRoles) { -%>
-        private partial Task HandleOpenAsync(<%= remoteRole.className %> <%= remoteRole.varName %>);
+        partial void HandleOpen(<%= remoteRole.className %> <%= remoteRole.varName %>);
 <% } -%>
 
-        public override async Task HandleMessageAsync(string messageName, JToken payload, RemoteRole remoteRole)
+        public override void HandleMessage(string messageName, JToken payload, RemoteRole remoteRole)
         {
             switch (messageName)
             {
@@ -34,8 +35,15 @@ namespace <%= ctx.namespace %>
                 case "<%= handler.messageName %>":
                     {
                         var message = payload.ToObject<<%= handler.modelClassName %>>();
+                        Handle<%= handler.methodName %>(payload);
+                        Handle<%= handler.methodName %>(message);
+                        On<%= handler.methodName %>?.Invoke(message);
+
 <% for (const remoteRole of ctx.remoteRoles) { %>
-                        await HandleMessageAsync(message, remoteRole as <%= remoteRole.className %>).ConfigureAwait(false);
+                        Handle<%= handler.methodName %>(payload, remoteRole as <%= remoteRole.className %>);
+                        HandleMessage(message, remoteRole as <%= remoteRole.className %>);
+                        On<%= handler.methodName %>From<%= remoteRole.className %>?.Invoke(message, remoteRole as <%= remoteRole.className %>);
+
 <% } -%>
                         break;
                     }
@@ -44,8 +52,15 @@ namespace <%= ctx.namespace %>
         }
 
 <% for (const handler of ctx.handlers) { -%>
+        public event Action<<%= handler.modelClassName -%>> On<%= handler.methodName -%>;
+        partial void Handle<%= handler.methodName %>(JToken payload);
+        partial void Handle<%= handler.methodName %>(<%= handler.modelClassName -%> payload);
+
 <% for (const remoteRole of ctx.remoteRoles) { -%>
-        private partial Task HandleMessageAsync(<%= handler.modelClassName %> payload, <%= remoteRole.className %> <%= remoteRole.varName %>);
+        public event Action<<%= handler.modelClassName -%>, <%= remoteRole.className -%>> On<%= handler.methodName -%>From<%= remoteRole.className -%>;
+        partial void Handle<%= handler.methodName %>(JToken payload, <%= remoteRole.className -%> <%= remoteRole.varName -%>);
+        partial void HandleMessage(<%= handler.modelClassName -%> payload, <%= remoteRole.className -%> <%= remoteRole.varName -%>);
+        
 <% } -%>
 <% } -%>
     }

package/dist/templates/dotnet/Model.cs.ejs

@@ -2,7 +2,7 @@ using Newtonsoft.Json;
 
 namespace <%= ctx.namespace %>
 {
-    public class <%= ctx.className %>
+    public partial class <%= ctx.className %>
     {
 <% for (const property of ctx.properties) { -%>
         [JsonProperty("<%= property.modelName %>")]

package/dist/templates/dotnet/RemoteRole.cs.ejs

@@ -14,7 +14,7 @@ namespace <%= ctx.namespace %>
         public override string Name { get; set; } = "<%= ctx.roleName %>";
         public override string Description { get; set; } = "<%= ctx.description ?? '' %>";
 <% if (ctx.endpoints && ctx.endpoints.length > 0) { -%>
-        public override IReadOnlyList<Endpoint> Endpoints { get; set; } = new List<Endpoint>
+        public static IReadOnlyList<Endpoint> Endpoints => new List<Endpoint>
         {
 <% for (const ep of ctx.endpoints) { -%>
             new Endpoint { Scheme = "<%= ep.scheme %>", Host = "<%= ep.host %>", Port = <%= ep.port %>, Path = "<%= ep.path %>" },
@@ -25,7 +25,12 @@ namespace <%= ctx.namespace %>
 <% for (const message of ctx.messages) { -%>
         public async Task <%= message.methodName %>Async(string fromRole, <%= message.modelClassName %> message)
         {
-            await SendMessageAsync(fromRole, "<%= message.messageName %>", message).ConfigureAwait(false);
+            await InternalSendMessageAsync(fromRole, "<%= message.messageName %>", message).ConfigureAwait(false);
+        }
+
+        public void <%= message.methodName %>(string fromRole, <%= message.modelClassName %> message)
+        {
+            InternalQueueMessage(fromRole, "<%= message.messageName %>", message);
         }
 
 <% } -%>

package/dist/templates/dotnet/UserHostRole.cs.ejs

@@ -1,4 +1,5 @@
 using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
 using Polytric.OpenWs.Core;
 <% for (const modelImport of ctx.modelImports) { -%>
 using <%= modelImport %>;
@@ -8,19 +9,40 @@ namespace <%= ctx.namespace %>
     public partial class <%= ctx.className %>
     {
 <% for (const remoteRole of ctx.remoteRoles) { -%>
-        private partial Task HandleOpenAsync(<%= remoteRole.className %> <%= remoteRole.varName %>)
+        partial void HandleOpen(<%= remoteRole.className %> <%= remoteRole.varName %>)
         {
             // TODO: Implement connection handling for <%= remoteRole.className %>
-            return Task.CompletedTask;
         }
 
 <% } -%>
 <% for (const handler of ctx.handlers) { -%>
+        partial void Handle<%= handler.methodName %>(JToken payload)
+        {
+            // TODO: Handle <%= handler.messageName %>
+            // Or implement the concrete payload method above. You only need to implement one.
+            // Removing this partial method will instruct the compiler to eliminate the call to save performance.
+        }
+
+        partial void Handle<%= handler.methodName %>(<%= handler.modelClassName %> payload)
+        {
+            // TODO: Handle <%= handler.messageName %>
+            // Or implement the JToken method above. You only need to implement one.
+            // Removing this partial method will instruct the compiler to eliminate the call to save performance.
+        }
+
 <% for (const remoteRole of ctx.remoteRoles) { -%>
-        private partial Task HandleMessageAsync(<%= handler.modelClassName %> payload, <%= remoteRole.className %> <%= remoteRole.varName %>)
+        partial void HandleMessage(<%= handler.modelClassName %> payload, <%= remoteRole.className %> <%= remoteRole.varName %>)
+        {
+            // TODO: Handle <%= handler.messageName %> from <%= remoteRole.className %>
+            // Or implement the JToken method below. You only need to implement one.
+            // Removing this partial method will instruct the compiler to eliminate the call to save performance.
+        }
+
+        partial void Handle<%= handler.methodName %>(JToken payload, <%= remoteRole.className %> <%= remoteRole.varName %>)
         {
             // TODO: Handle <%= handler.messageName %> from <%= remoteRole.className %>
-            return Task.CompletedTask;
+            // Or implement the concrete payload method above. You only need to implement one.
+            // Removing this partial method will instruct the compiler to eliminate the call to save performance.
         }
 
 <% } -%>