@polytric/openws-sdkgen 0.0.3 → 0.0.5

package/dist/plans/dotnet.d.cts

@@ -0,0 +1,113 @@
+import { Spec, Endpoint } from '@polytric/openws-spec/types';
+
+interface PipelineContext {
+    argv: string[];
+    rawInput?: RawInput;
+    request?: BuildRequest;
+    spec?: Spec;
+    ir?: IR;
+    plan?: PlanStep[];
+}
+interface RawInput {
+    spec: string;
+    out: string;
+    project: string;
+    hostRole: string[];
+    language: 'csharp' | 'javascript';
+    environment: 'unity' | 'node' | 'browser';
+    frameworks?: string[];
+}
+interface BuildRequest {
+    specPath: string;
+    outputPath: string;
+    project: string;
+    hostRoles: string[];
+    target: {
+        csharp?: {
+            environment: 'unity';
+            frameworks?: string[];
+        };
+        javascript?: {
+            environment: 'node' | 'browser';
+            frameworks?: string[];
+        };
+    };
+}
+interface IR {
+    package: IRPackage;
+    networks: IRNetwork[];
+    assemblyName?: string;
+}
+interface IRPackage {
+    project: string;
+    service: string;
+    description?: string;
+    version?: string;
+}
+interface IRNetwork {
+    name: string;
+    description?: string;
+    version?: string;
+    roles: IRRole[];
+    handlers: IRHandler[];
+    messages: IRMessage[];
+    models: IRModel[];
+}
+interface IRRole {
+    name: string;
+    description?: string;
+    isHost: boolean;
+    endpoints: Endpoint[];
+}
+interface IRHandler {
+    roleName: string;
+    handlerName: string;
+    description?: string;
+    modelClassName?: string;
+    messageName?: string;
+    methodName?: string;
+}
+interface IRMessage {
+    roleName: string;
+    handlerName: string;
+    description?: string;
+    modelClassName?: string;
+    messageName?: string;
+    methodName?: string;
+}
+interface IRModel {
+    scopeName: string;
+    modelName: string;
+    type: string;
+    description?: string;
+    properties?: IRProperty[];
+    namespace?: string;
+    className?: string;
+}
+interface IRProperty {
+    type: string;
+    scopeName: string;
+    modelName: string;
+    description?: string;
+    required?: boolean;
+    items?: {
+        type: string;
+        scopeName: string;
+        modelName: string;
+        description?: string;
+    };
+    propertyName?: string;
+    typeName?: string;
+}
+interface PlanStep {
+    name: string;
+    command: 'copy' | 'render';
+    input?: string;
+    output: string;
+    template?: string;
+    getData?: () => unknown;
+}
+
+declare function createPlan(ctx: PipelineContext): PipelineContext;
+
+export { createPlan as default };

package/dist/plans/dotnet.d.ts

@@ -0,0 +1,113 @@
+import { Spec, Endpoint } from '@polytric/openws-spec/types';
+
+interface PipelineContext {
+    argv: string[];
+    rawInput?: RawInput;
+    request?: BuildRequest;
+    spec?: Spec;
+    ir?: IR;
+    plan?: PlanStep[];
+}
+interface RawInput {
+    spec: string;
+    out: string;
+    project: string;
+    hostRole: string[];
+    language: 'csharp' | 'javascript';
+    environment: 'unity' | 'node' | 'browser';
+    frameworks?: string[];
+}
+interface BuildRequest {
+    specPath: string;
+    outputPath: string;
+    project: string;
+    hostRoles: string[];
+    target: {
+        csharp?: {
+            environment: 'unity';
+            frameworks?: string[];
+        };
+        javascript?: {
+            environment: 'node' | 'browser';
+            frameworks?: string[];
+        };
+    };
+}
+interface IR {
+    package: IRPackage;
+    networks: IRNetwork[];
+    assemblyName?: string;
+}
+interface IRPackage {
+    project: string;
+    service: string;
+    description?: string;
+    version?: string;
+}
+interface IRNetwork {
+    name: string;
+    description?: string;
+    version?: string;
+    roles: IRRole[];
+    handlers: IRHandler[];
+    messages: IRMessage[];
+    models: IRModel[];
+}
+interface IRRole {
+    name: string;
+    description?: string;
+    isHost: boolean;
+    endpoints: Endpoint[];
+}
+interface IRHandler {
+    roleName: string;
+    handlerName: string;
+    description?: string;
+    modelClassName?: string;
+    messageName?: string;
+    methodName?: string;
+}
+interface IRMessage {
+    roleName: string;
+    handlerName: string;
+    description?: string;
+    modelClassName?: string;
+    messageName?: string;
+    methodName?: string;
+}
+interface IRModel {
+    scopeName: string;
+    modelName: string;
+    type: string;
+    description?: string;
+    properties?: IRProperty[];
+    namespace?: string;
+    className?: string;
+}
+interface IRProperty {
+    type: string;
+    scopeName: string;
+    modelName: string;
+    description?: string;
+    required?: boolean;
+    items?: {
+        type: string;
+        scopeName: string;
+        modelName: string;
+        description?: string;
+    };
+    propertyName?: string;
+    typeName?: string;
+}
+interface PlanStep {
+    name: string;
+    command: 'copy' | 'render';
+    input?: string;
+    output: string;
+    template?: string;
+    getData?: () => unknown;
+}
+
+declare function createPlan(ctx: PipelineContext): PipelineContext;
+
+export { createPlan as default };

package/dist/plans/dotnet.js

@@ -0,0 +1,192 @@
+// src/plans/dotnet.ts
+import path from "path";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var TEMPLATE_DIR = path.join(__dirname, "../templates/dotnet");
+function pascalCase(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function camelCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function createPlan(ctx) {
+  const { ir, request } = ctx;
+  if (!ir) throw new Error("ir is required");
+  if (!request) throw new Error("request is required");
+  const assemblyName = `${pascalCase(ir.package.project)}.${pascalCase(ir.package.service)}.Sdk`;
+  ir.assemblyName = assemblyName;
+  const plan = [
+    {
+      name: "assembly definition",
+      command: "render",
+      getData: () => ir,
+      template: path.join(TEMPLATE_DIR, "Service.asmdef.ejs"),
+      output: path.join(request.outputPath, assemblyName, `${assemblyName}.asmdef`)
+    },
+    {
+      name: "user assembly reference",
+      command: "render",
+      getData: () => ir,
+      template: path.join(TEMPLATE_DIR, "UserService.asmref.ejs"),
+      output: path.join(
+        request.outputPath,
+        `${assemblyName}.User`,
+        `${assemblyName}.User.asmref`
+      )
+    }
+  ];
+  for (const networkIr of ir.networks) {
+    const networkNamespace = `${pascalCase(ir.package.project)}.${pascalCase(ir.package.service)}.${pascalCase(networkIr.name)}`;
+    const networkClassName = `${pascalCase(networkIr.name)}Network`;
+    const networkOutputPath = path.join(
+      request.outputPath,
+      assemblyName,
+      pascalCase(networkIr.name)
+    );
+    const userNetworkOutputPath = path.join(
+      request.outputPath,
+      `${assemblyName}.User`,
+      pascalCase(networkIr.name)
+    );
+    const hostRoles = [];
+    const remoteRoles = [];
+    for (const role of networkIr.roles) {
+      const roleInfo = {
+        roleName: role.name,
+        className: pascalCase(role.name),
+        varName: camelCase(role.name),
+        description: role.description || "",
+        baseClassName: role.isHost ? "HostRole" : "RemoteRole",
+        endpoints: role.endpoints || []
+      };
+      if (role.isHost) {
+        hostRoles.push(roleInfo);
+      } else {
+        remoteRoles.push(roleInfo);
+      }
+    }
+    const allRoles = [...hostRoles, ...remoteRoles];
+    const allModelImports = allRoles.map((role) => `${networkNamespace}.Models.${role.className}`);
+    plan.push({
+      name: `network ${networkIr.name}`,
+      command: "render",
+      getData: () => ({
+        namespace: networkNamespace,
+        networkClassName,
+        networkName: networkIr.name,
+        description: networkIr.description,
+        version: networkIr.version,
+        allRoles
+      }),
+      template: path.join(TEMPLATE_DIR, "Network.cs.ejs"),
+      output: path.join(networkOutputPath, `${networkClassName}.cs`)
+    });
+    for (const modelIr of networkIr.models) {
+      modelIr.namespace = `${networkNamespace}.Models.${pascalCase(modelIr.scopeName)}`;
+      modelIr.className = pascalCase(modelIr.modelName);
+      if (modelIr.properties) {
+        for (const propertyIr of modelIr.properties) {
+          propertyIr.propertyName = pascalCase(propertyIr.modelName);
+          propertyIr.typeName = mapType(propertyIr);
+        }
+      }
+    }
+    for (const handlerIr of networkIr.handlers) {
+      handlerIr.modelClassName = pascalCase(handlerIr.handlerName) + "Payload";
+      handlerIr.messageName = handlerIr.handlerName;
+      handlerIr.methodName = pascalCase(handlerIr.handlerName);
+    }
+    for (const messageIr of networkIr.messages) {
+      messageIr.modelClassName = pascalCase(messageIr.handlerName) + "Payload";
+      messageIr.messageName = messageIr.handlerName;
+      messageIr.methodName = pascalCase(messageIr.handlerName);
+    }
+    for (const hostRole of hostRoles) {
+      const roleHandlers = networkIr.handlers.filter((h) => h.roleName === hostRole.roleName);
+      const modelImports = [`${networkNamespace}.Models.${hostRole.className}`];
+      plan.push({
+        name: `host role ${hostRole.className}`,
+        command: "render",
+        getData: () => ({
+          namespace: `${networkNamespace}.Roles`,
+          handlers: roleHandlers,
+          remoteRoles,
+          modelImports,
+          ...hostRole
+        }),
+        template: path.join(TEMPLATE_DIR, "HostRole.cs.ejs"),
+        output: path.join(networkOutputPath, "Roles", `${hostRole.className}.cs`)
+      });
+      plan.push({
+        name: `user host role ${hostRole.className}`,
+        command: "render",
+        getData: () => ({
+          namespace: `${networkNamespace}.Roles`,
+          handlers: roleHandlers,
+          remoteRoles,
+          modelImports: allModelImports,
+          ...hostRole
+        }),
+        template: path.join(TEMPLATE_DIR, "UserHostRole.cs.ejs"),
+        output: path.join(userNetworkOutputPath, "Roles", `${hostRole.className}.cs`)
+      });
+    }
+    for (const remoteRole of remoteRoles) {
+      const roleMessages = networkIr.messages.filter((m) => m.roleName === remoteRole.roleName);
+      const modelImports = [`${networkNamespace}.Models.${remoteRole.className}`];
+      plan.push({
+        name: `remote role ${remoteRole.className}`,
+        command: "render",
+        getData: () => ({
+          namespace: `${networkNamespace}.Roles`,
+          messages: roleMessages,
+          modelImports,
+          ...remoteRole
+        }),
+        template: path.join(TEMPLATE_DIR, "RemoteRole.cs.ejs"),
+        output: path.join(networkOutputPath, "Roles", `${remoteRole.className}.cs`)
+      });
+    }
+    for (const modelIr of networkIr.models) {
+      if (modelIr.type !== "object") continue;
+      plan.push({
+        name: `model ${modelIr.className}`,
+        command: "render",
+        getData: () => modelIr,
+        template: path.join(TEMPLATE_DIR, "Model.cs.ejs"),
+        output: path.join(
+          networkOutputPath,
+          "Models",
+          pascalCase(modelIr.scopeName),
+          `${modelIr.className}.cs`
+        )
+      });
+    }
+  }
+  return {
+    ...ctx,
+    plan
+  };
+}
+function mapType(property) {
+  switch (property.type) {
+    case "string":
+      return "string";
+    case "number":
+      return "double";
+    case "integer":
+      return "int";
+    case "boolean":
+      return "bool";
+    case "array":
+      if (!property.items) return "List<object>";
+      return `List<${mapType(property.items)}>`;
+    case "object":
+      return pascalCase(property.modelName);
+    default:
+      return "object";
+  }
+}
+export {
+  createPlan as default
+};

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

@@ -0,0 +1,67 @@
+using System;
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+using Polytric.OpenWs.Core;
+<% for (const modelImport of ctx.modelImports) { -%>
+using <%= modelImport %>;
+<% } -%>
+
+namespace <%= ctx.namespace %>
+{
+    public partial class <%= ctx.className %> : <%= ctx.baseClassName %>
+    {
+        public string Name => "<%= ctx.roleName %>";
+        public string Description => "<%= ctx.description ?? '' %>";
+
+        public override void HandleOpen(RemoteRole remoteRole)
+        {
+<% for (const remoteRole of ctx.remoteRoles) { %>
+            if (remoteRole is <%= remoteRole.className %> <%= remoteRole.varName %>)
+            {
+                HandleOpen(<%= remoteRole.varName %>);
+            }
+<% } -%>
+        }
+
+<% for (const remoteRole of ctx.remoteRoles) { -%>
+        partial void HandleOpen(<%= remoteRole.className %> <%= remoteRole.varName %>);
+<% } -%>
+
+        public override void HandleMessage(string messageName, JToken payload, RemoteRole remoteRole)
+        {
+            switch (messageName)
+            {
+<% for (const handler of ctx.handlers) { %>
+                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) { %>
+                        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;
+                    }
+<% } -%>
+            }
+        }
+
+<% 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) { -%>
+        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/{src/dotnet/template → 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/{src/dotnet/template → 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

@@ -0,0 +1,51 @@
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+using Polytric.OpenWs.Core;
+<% for (const modelImport of ctx.modelImports) { -%>
+using <%= modelImport %>;
+<% } %>
+namespace <%= ctx.namespace %>
+{
+    public partial class <%= ctx.className %>
+    {
+<% for (const remoteRole of ctx.remoteRoles) { -%>
+        partial void HandleOpen(<%= remoteRole.className %> <%= remoteRole.varName %>)
+        {
+            // TODO: Implement connection handling for <%= remoteRole.className %>
+        }
+
+<% } -%>
+<% 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) { -%>
+        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 %>
+            // 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.
+        }
+
+<% } -%>
+<% } -%>
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polytric/openws-sdkgen",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "OpenWS SDK generator CLI",
   "type": "module",
   "bin": {
@@ -8,7 +8,6 @@
   },
   "files": [
     "dist",
-    "src/dotnet/template",
     "LICENSE",
     "README.md"
   ],
@@ -35,8 +34,10 @@
   },
   "dependencies": {
     "@pocketgems/schema": "^0.1.3",
+    "ajv": "^8.17.1",
     "ejs": "^3.1.10",
-    "yargs": "^18.0.0"
+    "yargs": "^18.0.0",
+    "@polytric/openws-spec": "0.0.4"
   },
   "devDependencies": {
     "@types/ejs": "^3.1.5",
@@ -49,7 +50,6 @@
   "scripts": {
     "build": "tsup",
     "typecheck": "tsc --noEmit",
-    "generate": "tsx src/main.ts",
-    "test:csharp:unity": "tsx src/main.ts --spec ./test/spec.json --out ./generated/dotnet/unity --project Example --hostRole client --language csharp --environment unity"
+    "test:csharp:unity": "node dist/main.cjs --spec ./test/spec.json --out ./generated/dotnet/unity --project Example --hostRole client --language csharp --environment unity"
   }
 }

package/src/dotnet/template/HostRole.cs.ejs

@@ -1,52 +0,0 @@
-using System.Threading.Tasks;
-using Newtonsoft.Json.Linq;
-using Polytric.OpenWs.Core;
-<% for (const modelImport of ctx.modelImports) { -%>
-using <%= modelImport %>;
-<% } -%>
-
-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 override async Task HandleOpenAsync(RemoteRole remoteRole)
-        {
-<% for (const remoteRole of ctx.remoteRoles) { %>
-            if (remoteRole is <%= remoteRole.className %> <%= remoteRole.varName %>)
-            {
-                await HandleOpenAsync(<%= remoteRole.varName %>).ConfigureAwait(false);
-            }
-<% } -%>
-        }
-
-<% for (const remoteRole of ctx.remoteRoles) { -%>
-        private partial Task HandleOpenAsync(<%= remoteRole.className %> <%= remoteRole.varName %>);
-<% } -%>
-
-        public override async Task HandleMessageAsync(string messageName, JToken payload, RemoteRole remoteRole)
-        {
-            switch (messageName)
-            {
-<% for (const handler of ctx.handlers) { %>
-                case "<%= handler.messageName %>":
-                    {
-                        var message = payload.ToObject<<%= handler.modelClassName %>>();
-<% for (const remoteRole of ctx.remoteRoles) { %>
-                        await HandleMessageAsync(message, remoteRole as <%= remoteRole.className %>).ConfigureAwait(false);
-<% } -%>
-                        break;
-                    }
-<% } -%>
-            }
-        }
-
-<% for (const handler of ctx.handlers) { -%>
-<% for (const remoteRole of ctx.remoteRoles) { -%>
-        private partial Task HandleMessageAsync(<%= handler.modelClassName %> payload, <%= remoteRole.className %> <%= remoteRole.varName %>);
-<% } -%>
-<% } -%>
-    }
-}

package/src/dotnet/template/UserHostRole.cs.ejs

@@ -1,29 +0,0 @@
-using System.Threading.Tasks;
-using Polytric.OpenWs.Core;
-<% for (const modelImport of ctx.modelImports) { -%>
-using <%= modelImport %>;
-<% } %>
-namespace <%= ctx.namespace %>
-{
-    public partial class <%= ctx.className %>
-    {
-<% for (const remoteRole of ctx.remoteRoles) { -%>
-        private partial Task HandleOpenAsync(<%= remoteRole.className %> <%= remoteRole.varName %>)
-        {
-            // TODO: Implement connection handling for <%= remoteRole.className %>
-            return Task.CompletedTask;
-        }
-
-<% } -%>
-<% for (const handler of ctx.handlers) { -%>
-<% for (const remoteRole of ctx.remoteRoles) { -%>
-        private partial Task HandleMessageAsync(<%= handler.modelClassName %> payload, <%= remoteRole.className %> <%= remoteRole.varName %>)
-        {
-            // TODO: Handle <%= handler.messageName %> from <%= remoteRole.className %>
-            return Task.CompletedTask;
-        }
-
-<% } -%>
-<% } -%>
-    }
-}