@polytric/openws-sdkgen 0.0.2 → 0.0.3

package/dist/main.cjs

@@ -0,0 +1,609 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/tsup@8.5.1_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/build-ir.ts
+var import_schema = __toESM(require("@pocketgems/schema"), 1);
+var validateIr = import_schema.default.obj({
+  package: import_schema.default.obj({
+    project: import_schema.default.str,
+    service: import_schema.default.str,
+    description: import_schema.default.str.optional(),
+    version: import_schema.default.str.optional()
+  }),
+  networks: import_schema.default.arr(
+    import_schema.default.obj({
+      name: import_schema.default.str,
+      description: import_schema.default.str.optional(),
+      version: import_schema.default.str.optional(),
+      roles: import_schema.default.arr(
+        import_schema.default.obj({
+          name: import_schema.default.str,
+          description: import_schema.default.str.optional(),
+          isHost: import_schema.default.bool,
+          endpoints: import_schema.default.arr(
+            import_schema.default.obj({
+              scheme: import_schema.default.str.enum("ws", "wss"),
+              host: import_schema.default.str,
+              port: import_schema.default.int.min(0).max(65535),
+              path: import_schema.default.str
+            })
+          )
+        })
+      ),
+      handlers: import_schema.default.arr(
+        import_schema.default.obj({
+          roleName: import_schema.default.str,
+          handlerName: import_schema.default.str,
+          description: import_schema.default.str.optional()
+        })
+      ),
+      messages: import_schema.default.arr(
+        import_schema.default.obj({
+          roleName: import_schema.default.str,
+          handlerName: import_schema.default.str,
+          description: import_schema.default.str.optional()
+        })
+      ),
+      models: import_schema.default.arr(
+        import_schema.default.obj({
+          scopeName: import_schema.default.str,
+          modelName: import_schema.default.str,
+          type: import_schema.default.str,
+          description: import_schema.default.str.optional(),
+          properties: import_schema.default.arr(
+            import_schema.default.obj({
+              type: import_schema.default.str,
+              scopeName: import_schema.default.str,
+              modelName: import_schema.default.str,
+              description: import_schema.default.str.optional(),
+              required: import_schema.default.bool.optional(),
+              items: import_schema.default.obj({
+                type: import_schema.default.str,
+                scopeName: import_schema.default.str,
+                modelName: import_schema.default.str,
+                description: import_schema.default.str.optional()
+              }).optional()
+            })
+          ).optional()
+        })
+      )
+    })
+  ).desc("An array of network definitions")
+}).compile("IrValidator");
+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": {
+      if (!schema.items) return [];
+      return buildIrModels(scopeName, modelName, schema.items);
+    }
+    case "object": {
+      const properties = [];
+      model.properties = properties;
+      const models = [];
+      if (!schema.properties) return [model];
+      for (const [subName, subSchema] of Object.entries(schema.properties)) {
+        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 buildIr(ctx) {
+  const { request, spec } = ctx;
+  if (!request) throw new Error("request is required");
+  if (!spec) throw new Error("spec is required");
+  const { hostRoles } = request;
+  const ir = {
+    package: {
+      project: request.project,
+      service: spec.name,
+      description: spec.description,
+      version: spec.version
+    },
+    networks: []
+  };
+  for (const [networkName, networkSpec] of Object.entries(spec.networks)) {
+    const hostRoleSpecs = hostRoles.map((hostRole) => networkSpec.roles[hostRole]);
+    const otherRoleSpecs = {};
+    for (const [roleName, roleSpec] of Object.entries(networkSpec.roles)) {
+      if (!hostRoles.includes(roleName)) {
+        otherRoleSpecs[roleName] = roleSpec;
+      }
+    }
+    const requiredRoles = /* @__PURE__ */ new Set();
+    for (const hostRoleSpec of hostRoleSpecs) {
+      for (const handlerSpec of Object.values(hostRoleSpec.messages)) {
+        if (handlerSpec.from) {
+          for (const fromRoleName of handlerSpec.from) {
+            requiredRoles.add(fromRoleName);
+          }
+        } else {
+          for (const key of Object.keys(otherRoleSpecs)) {
+            requiredRoles.add(key);
+          }
+          break;
+        }
+      }
+    }
+    const irNetwork = {
+      name: networkName,
+      description: networkSpec.description,
+      version: networkSpec.version,
+      roles: [],
+      handlers: [],
+      messages: [],
+      models: []
+    };
+    for (const hostRoleSpec of hostRoleSpecs) {
+      irNetwork.roles.push({
+        name: hostRoleSpec.name,
+        description: hostRoleSpec.description,
+        isHost: true,
+        endpoints: hostRoleSpec.endpoints || []
+      });
+      for (const [handlerName, handlerSpec] of Object.entries(hostRoleSpec.messages)) {
+        irNetwork.handlers.push({
+          roleName: hostRoleSpec.name,
+          handlerName,
+          description: handlerSpec.description
+        });
+        irNetwork.models.push(
+          ...buildIrModels(hostRoleSpec.name, handlerName, handlerSpec.payload)
+        );
+      }
+    }
+    for (const [roleName, roleSpec] of Object.entries(otherRoleSpecs)) {
+      if (!requiredRoles.has(roleName)) continue;
+      irNetwork.roles.push({
+        name: roleName,
+        description: roleSpec.description,
+        isHost: false,
+        endpoints: roleSpec.endpoints || []
+      });
+      for (const [handlerName, handlerSpec] of Object.entries(roleSpec.messages)) {
+        irNetwork.messages.push({
+          roleName,
+          handlerName,
+          description: handlerSpec.description
+        });
+        irNetwork.models.push(...buildIrModels(roleName, handlerName, handlerSpec.payload));
+      }
+    }
+    ir.networks.push(irNetwork);
+  }
+  validateIr(ir);
+  return {
+    ...ctx,
+    ir
+  };
+}
+
+// src/dotnet/build-plan.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var __dirname = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+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: import_node_path.default.join(__dirname, "template", "Service.asmdef.ejs"),
+      output: import_node_path.default.join(request.outputPath, assemblyName, `${assemblyName}.asmdef`)
+    },
+    {
+      name: "user assembly reference",
+      command: "render",
+      getData: () => ir,
+      template: import_node_path.default.join(__dirname, "template", "UserService.asmref.ejs"),
+      output: import_node_path.default.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 = import_node_path.default.join(
+      request.outputPath,
+      assemblyName,
+      pascalCase(networkIr.name)
+    );
+    const userNetworkOutputPath = import_node_path.default.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: import_node_path.default.join(__dirname, "template", "Network.cs.ejs"),
+      output: import_node_path.default.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);
+      handlerIr.messageName = handlerIr.handlerName;
+      handlerIr.methodName = pascalCase(handlerIr.handlerName);
+    }
+    for (const messageIr of networkIr.messages) {
+      messageIr.modelClassName = pascalCase(messageIr.handlerName);
+      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: import_node_path.default.join(__dirname, "template", "HostRole.cs.ejs"),
+        output: import_node_path.default.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: import_node_path.default.join(__dirname, "template", "UserHostRole.cs.ejs"),
+        output: import_node_path.default.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: import_node_path.default.join(__dirname, "template", "RemoteRole.cs.ejs"),
+        output: import_node_path.default.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: import_node_path.default.join(__dirname, "template", "Model.cs.ejs"),
+        output: import_node_path.default.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";
+  }
+}
+
+// src/build-plan.ts
+var planIndex = {
+  csharp: {
+    unity: createPlan
+  }
+};
+function dispatchBuildPlan(ctx) {
+  const { request } = ctx;
+  if (!request) throw new Error("request is required");
+  const language = Object.keys(request.target)[0];
+  const targetConfig = request.target[language];
+  if (!targetConfig) throw new Error(`No target config for language: ${language}`);
+  const environment = targetConfig.environment;
+  const plan = planIndex[language]?.[environment];
+  if (!plan) throw new Error(`No plan for ${language}/${environment}`);
+  return plan(ctx);
+}
+
+// src/build-request.ts
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_process = __toESM(require("process"), 1);
+var import_schema2 = __toESM(require("@pocketgems/schema"), 1);
+var validateBuildRequest = import_schema2.default.obj({
+  specPath: import_schema2.default.str,
+  outputPath: import_schema2.default.str,
+  project: import_schema2.default.str,
+  hostRoles: import_schema2.default.arr(import_schema2.default.str),
+  target: import_schema2.default.obj({
+    csharp: import_schema2.default.obj({
+      environment: import_schema2.default.str.enum("unity"),
+      frameworks: import_schema2.default.arr(import_schema2.default.str.enum("newtonsoft")).optional()
+    }).optional(),
+    javascript: import_schema2.default.obj({
+      environment: import_schema2.default.str.enum("node", "browser"),
+      frameworks: import_schema2.default.arr(import_schema2.default.str.enum("fastify")).optional()
+    }).optional()
+  }).min(1).max(1).desc("The target platform to generate code for")
+}).compile("BuildRequestValidator");
+function buildRequest(ctx) {
+  const { rawInput } = ctx;
+  if (!rawInput) throw new Error("rawInput is required");
+  console.log("Host roles:", rawInput.hostRole);
+  const request = {
+    specPath: import_node_path2.default.join(import_node_process.default.cwd(), rawInput.spec),
+    outputPath: import_node_path2.default.join(import_node_process.default.cwd(), rawInput.out),
+    project: rawInput.project,
+    hostRoles: rawInput.hostRole,
+    target: {
+      [rawInput.language]: {
+        environment: rawInput.environment,
+        frameworks: rawInput.frameworks
+      }
+    }
+  };
+  validateBuildRequest(request);
+  return {
+    ...ctx,
+    request
+  };
+}
+
+// src/execute-plan.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_ejs = __toESM(require("ejs"), 1);
+var rendererCache = {};
+function renderTemplate(templatePath, data) {
+  if (rendererCache[templatePath]) {
+    return rendererCache[templatePath](data);
+  }
+  const templateContent = import_node_fs.default.readFileSync(templatePath, "utf8");
+  const renderer = import_ejs.default.compile(templateContent);
+  rendererCache[templatePath] = renderer;
+  return renderer(data);
+}
+function executePlan(ctx) {
+  const { plan } = ctx;
+  if (!plan) throw new Error("plan is required");
+  for (const step of plan) {
+    switch (step.command) {
+      case "copy":
+        if (step.input) {
+          import_node_fs.default.cpSync(step.input, step.output, { recursive: true });
+        }
+        break;
+      case "render": {
+        const { getData, template, output } = step;
+        if (!getData || !template) continue;
+        const data = getData();
+        console.log(data);
+        import_node_fs.default.mkdirSync(import_node_path3.default.dirname(output), { recursive: true });
+        import_node_fs.default.writeFileSync(output, renderTemplate(template, { ctx: data }));
+        break;
+      }
+    }
+  }
+  return ctx;
+}
+
+// src/load-spec.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+function loadSpec(ctx) {
+  const { request } = ctx;
+  if (!request) throw new Error("request is required");
+  const { specPath } = request;
+  const spec = JSON.parse(import_node_fs2.default.readFileSync(specPath, "utf8"));
+  return {
+    ...ctx,
+    spec
+  };
+}
+
+// src/parse-input.ts
+var import_yargs = __toESM(require("yargs"), 1);
+var import_helpers = require("yargs/helpers");
+function parseInput(ctx) {
+  const args = (0, import_yargs.default)((0, import_helpers.hideBin)(ctx.argv)).scriptName("openws-sdkgen").version(false).option("spec", {
+    type: "string",
+    description: "The path to the OpenWS spec file",
+    demandOption: true
+  }).option("out", {
+    type: "string",
+    description: "The path to the output directory",
+    demandOption: true
+  }).option("project", {
+    type: "string",
+    description: "The project name",
+    demandOption: true
+  }).option("hostRole", {
+    type: "array",
+    string: true,
+    description: "The target participant roles that use the generated code",
+    demandOption: true
+  }).option("language", {
+    type: "string",
+    description: "The language to generate code for",
+    choices: ["csharp", "javascript"],
+    default: "csharp"
+  }).option("environment", {
+    type: "string",
+    description: "The environment to generate code for",
+    choices: ["unity", "node", "browser"],
+    default: "unity"
+  }).option("frameworks", {
+    type: "array",
+    string: true,
+    description: "The frameworks to generate code for",
+    choices: ["fastify", "newtonsoft"]
+  }).strict().help().parseSync();
+  return {
+    ...ctx,
+    rawInput: args
+  };
+}
+
+// src/prepare-output.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+function prepareOutput(ctx) {
+  const { request } = ctx;
+  if (!request) throw new Error("request is required");
+  const { outputPath } = request;
+  import_node_fs3.default.rmSync(outputPath, { recursive: true, force: true });
+  import_node_fs3.default.mkdirSync(outputPath, { recursive: true });
+  return ctx;
+}
+
+// src/main.ts
+var Pipeline = [
+  parseInput,
+  buildRequest,
+  prepareOutput,
+  loadSpec,
+  buildIr,
+  dispatchBuildPlan,
+  executePlan
+];
+function main() {
+  return Pipeline.reduce((acc, step) => step(acc), { argv: process.argv });
+}
+console.log(JSON.stringify(main(), null, 2));

package/package.json

@@ -1,17 +1,14 @@
 {
   "name": "@polytric/openws-sdkgen",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "OpenWS SDK generator CLI",
-  "license": "Apache-2.0",
-  "author": "Polytric",
-  "engines": {
-    "node": ">=18"
-  },
+  "type": "module",
   "bin": {
-    "openws-sdkgen": "./src/main.js"
+    "openws-sdkgen": "./dist/main.cjs"
   },
   "files": [
-    "src",
+    "dist",
+    "src/dotnet/template",
     "LICENSE",
     "README.md"
   ],
@@ -23,6 +20,11 @@
     "unity",
     "dotnet"
   ],
+  "author": "Polytric",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=20"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/AgeOfLearning/openws.git",
@@ -36,5 +38,18 @@
     "ejs": "^3.1.10",
     "yargs": "^18.0.0"
   },
-  "scripts": {}
+  "devDependencies": {
+    "@types/ejs": "^3.1.5",
+    "@types/node": "^22.15.29",
+    "@types/yargs": "^17.0.33",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "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"
+  }
 }

package/src/build-ir.js

@@ -1,220 +0,0 @@
-const S = require('@pocketgems/schema')
-
-const validateIr = S.obj({
-    package: S.obj({
-        project: S.str,
-        service: S.str,
-        description: S.str.optional(),
-        version: S.str.optional(),
-    }),
-    networks: S.arr(
-        S.obj({
-            name: S.str,
-            description: S.str.optional(),
-            version: S.str.optional(),
-            roles: S.arr(
-                S.obj({
-                    name: S.str,
-                    description: S.str.optional(),
-                    isHost: S.bool,
-                    endpoints: S.arr(
-                        S.obj({
-                            scheme: S.str.enum('ws', 'wss'),
-                            host: S.str,
-                            port: S.int.min(0).max(65535),
-                            path: S.str,
-                        })
-                    ),
-                })
-            ),
-            handlers: S.arr(
-                S.obj({
-                    roleName: S.str,
-                    handlerName: S.str,
-                    description: S.str.optional(),
-                })
-            ),
-            messages: S.arr(
-                S.obj({
-                    roleName: S.str,
-                    handlerName: S.str,
-                    description: S.str.optional(),
-                })
-            ),
-            models: S.arr(
-                S.obj({
-                    scopeName: S.str,
-                    modelName: S.str,
-                    type: S.str,
-                    description: S.str.optional(),
-                    properties: S.arr(
-                        S.obj({
-                            type: S.str,
-                            scopeName: S.str,
-                            modelName: S.str,
-                            description: S.str.optional(),
-                            required: S.bool.optional(),
-                            items: S.obj({
-                                type: S.str,
-                                scopeName: S.str,
-                                modelName: S.str,
-                                description: S.str.optional(),
-                            }).optional(),
-                        })
-                    ).optional(),
-                })
-            ),
-        })
-    ).desc('An array of network definitions'),
-}).compile('IrValidator')
-
-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': {
-            return buildIrModels(scopeName, modelName, schema.items)
-        }
-        case 'object': {
-            const properties = []
-            model.properties = properties
-            const models = []
-            for (const [subName, subSchema] of Object.entries(schema.properties)) {
-                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),
-                }
-
-                if (mainModel.items) {
-                    property.items = {
-                        type: mainModel.items.type,
-                        description: mainModel.items.description,
-                        scopeName: mainModel.items.scopeName ?? scopeName,
-                        modelName: mainModel.items.modelName ?? subName,
-                    }
-                }
-                properties.push(property)
-                models.push(...subModels)
-            }
-            return [model, ...models]
-        }
-    }
-}
-
-module.exports = function buildIr(ctx) {
-    const { request, spec } = ctx
-    const { hostRoles } = request
-
-    const irPackage = {
-        project: request.project,
-        service: spec.name,
-        description: spec.description,
-        version: spec.version,
-    }
-    const irNetworks = []
-    const ir = {
-        package: irPackage,
-        networks: irNetworks,
-    }
-
-    for (const [networkName, networkSpec] of Object.entries(spec.networks)) {
-        const hostRoleSpecs = hostRoles.map(hostRole => networkSpec.roles[hostRole])
-        const otherRoleSpecs = {}
-        for (const [roleName, roleSpec] of Object.entries(networkSpec.roles)) {
-            if (!hostRoles.includes(roleName)) {
-                otherRoleSpecs[roleName] = roleSpec
-            }
-        }
-
-        const requiredRoles = new Set()
-        for (const hostRoleSpec of hostRoleSpecs) {
-            for (const handlerSpec of Object.values(hostRoleSpec.messages)) {
-                if (handlerSpec.from) {
-                    for (const fromRoleName of handlerSpec.from) {
-                        requiredRoles.add(fromRoleName)
-                    }
-                } else {
-                    requiredRoles.add(...Object.keys(otherRoleSpecs))
-                    break
-                }
-            }
-        }
-
-        const irRoles = []
-        const irHandlers = []
-        const irMessages = []
-        const irModels = []
-
-        // Add host roles
-        for (const hostRoleSpec of hostRoleSpecs) {
-            irRoles.push({
-                name: hostRoleSpec.name,
-                description: hostRoleSpec.description,
-                isHost: true,
-                endpoints: hostRoleSpec.endpoints || [],
-            })
-            for (const [handlerName, handlerSpec] of Object.entries(hostRoleSpec.messages)) {
-                irHandlers.push({
-                    roleName: hostRoleSpec.name,
-                    handlerName,
-                    description: handlerSpec.description,
-                })
-                irModels.push(...buildIrModels(hostRoleSpec.name, handlerName, handlerSpec.payload))
-            }
-        }
-
-        // Add remote roles
-        for (const [roleName, roleSpec] of Object.entries(otherRoleSpecs)) {
-            if (!requiredRoles.has(roleName)) {
-                continue
-            }
-            irRoles.push({
-                name: roleName,
-                description: roleSpec.description,
-                isHost: false,
-                endpoints: roleSpec.endpoints || [],
-            })
-            for (const [handlerName, handlerSpec] of Object.entries(roleSpec.messages)) {
-                irMessages.push({
-                    roleName,
-                    handlerName,
-                    description: handlerSpec.description,
-                })
-                irModels.push(...buildIrModels(roleName, handlerName, handlerSpec.payload))
-            }
-        }
-
-        const irNetwork = {
-            name: networkName,
-            description: networkSpec.description,
-            version: networkSpec.version,
-            roles: irRoles,
-            handlers: irHandlers,
-            messages: irMessages,
-            models: irModels,
-        }
-        irNetworks.push(irNetwork)
-    }
-
-    validateIr(ir)
-    return {
-        ...ctx,
-        ir,
-    }
-}

package/src/build-plan.js

@@ -1,16 +0,0 @@
-const path = require('node:path')
-
-const planIndex = {
-    csharp: {
-        unity: './dotnet/build-plan.js',
-    },
-}
-
-module.exports = function dispatchBuildPlan(ctx) {
-    const { request } = ctx
-    const language = Object.keys(request.target)[0]
-    const environment = request.target[language].environment
-    const templatePath = planIndex[language][environment]
-    const plan = require(path.join(__dirname, templatePath))
-    return plan(ctx)
-}

package/src/build-request.js

@@ -1,46 +0,0 @@
-const path = require('node:path')
-const { cwd } = require('node:process')
-
-const S = require('@pocketgems/schema')
-
-const validateBuildRequest = S.obj({
-    specPath: S.str,
-    outputPath: S.str,
-    project: S.str,
-    hostRoles: S.arr(S.str),
-    target: S.obj({
-        csharp: S.obj({
-            environment: S.str.enum('unity'), // aspnet
-            frameworks: S.arr(S.str.enum('newtonsoft')).optional(),
-        }).optional(),
-        javascript: S.obj({
-            environment: S.str.enum('node'), // browser
-            frameworks: S.arr(S.str.enum('fastify')).optional(),
-        }).optional(),
-    })
-        .min(1)
-        .max(1)
-        .desc('The target platform to generate code for'),
-}).compile('BuildRequestValidator')
-
-module.exports = function buildRequest(ctx) {
-    const { rawInput } = ctx
-    console.log(rawInput.hostRole)
-    const request = {
-        specPath: path.join(process.cwd(), rawInput.spec),
-        outputPath: path.join(process.cwd(), rawInput.out),
-        project: rawInput.project,
-        hostRoles: rawInput.hostRole, // naming oddity from cli --hostRole serverA --hostRole serverB is readable as singular hostRole
-        target: {
-            [rawInput.language]: {
-                environment: rawInput.environment,
-                frameworks: rawInput.frameworks,
-            },
-        },
-    }
-    validateBuildRequest(request)
-    return {
-        ...ctx,
-        request,
-    }
-}

package/src/dotnet/build-plan.js

@@ -1,215 +0,0 @@
-const path = require('node:path')
-
-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
-    const assemblyName = `${pascalCase(ir.package.project)}.${pascalCase(ir.package.service)}.Sdk`
-    ir.assemblyName = assemblyName
-
-    const plan = [
-        {
-            name: 'assembly definition',
-            command: 'render',
-            getData: () => ctx.ir,
-            template: path.join(__dirname, 'template', 'Service.asmdef.ejs'),
-            output: path.join(ctx.request.outputPath, assemblyName, `${assemblyName}.asmdef`),
-        },
-        {
-            name: 'user assembly reference',
-            command: 'render',
-            getData: () => ctx.ir,
-            template: path.join(__dirname, 'template', 'UserService.asmref.ejs'),
-            output: path.join(
-                ctx.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(
-            ctx.request.outputPath,
-            assemblyName,
-            pascalCase(networkIr.name)
-        )
-        const userNetworkOutputPath = path.join(
-            ctx.request.outputPath,
-            `${assemblyName}.User`,
-            pascalCase(networkIr.name)
-        )
-
-        // Build role info from IR
-        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]
-
-        // Build all model imports for user templates
-        const allModelImports = allRoles.map(role => `${networkNamespace}.Models.${role.className}`)
-
-        // Generate Network.cs
-        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(__dirname, 'template', 'Network.cs.ejs'),
-            output: path.join(networkOutputPath, `${networkClassName}.cs`),
-        })
-
-        // Process models
-        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)
-                }
-            }
-        }
-
-        // Process handlers (incoming messages for host roles)
-        for (const handlerIr of networkIr.handlers) {
-            handlerIr.modelClassName = pascalCase(handlerIr.handlerName)
-            handlerIr.messageName = handlerIr.handlerName
-            handlerIr.methodName = pascalCase(handlerIr.handlerName)
-        }
-
-        // Process messages (outgoing messages to remote roles)
-        for (const messageIr of networkIr.messages) {
-            messageIr.modelClassName = pascalCase(messageIr.handlerName)
-            messageIr.messageName = messageIr.handlerName
-            messageIr.methodName = pascalCase(messageIr.handlerName)
-        }
-
-        // Generate HostRole classes
-        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(__dirname, 'template', 'HostRole.cs.ejs'),
-                output: path.join(networkOutputPath, 'Roles', `${hostRole.className}.cs`),
-            })
-
-            // Generate User stub for HostRole
-            plan.push({
-                name: `user host role ${hostRole.className}`,
-                command: 'render',
-                getData: () => ({
-                    namespace: `${networkNamespace}.Roles`,
-                    handlers: roleHandlers,
-                    remoteRoles,
-                    modelImports: allModelImports,
-                    ...hostRole,
-                }),
-                template: path.join(__dirname, 'template', 'UserHostRole.cs.ejs'),
-                output: path.join(userNetworkOutputPath, 'Roles', `${hostRole.className}.cs`),
-            })
-        }
-
-        // Generate RemoteRole classes
-        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(__dirname, 'template', 'RemoteRole.cs.ejs'),
-                output: path.join(networkOutputPath, 'Roles', `${remoteRole.className}.cs`),
-            })
-        }
-
-        // Generate Models
-        for (const modelIr of networkIr.models) {
-            if (modelIr.type !== 'object') continue
-            plan.push({
-                name: `model ${modelIr.className}`,
-                command: 'render',
-                getData: () => modelIr,
-                template: path.join(__dirname, 'template', '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':
-            return `List<${mapType(property.items)}>`
-        case 'object':
-            return pascalCase(property.modelName)
-        default:
-            return 'object'
-    }
-}
-
-module.exports = createPlan

package/src/execute-plan.js

@@ -1,38 +0,0 @@
-const fs = require('node:fs')
-const path = require('node:path')
-
-const ejs = require('ejs')
-
-const rendererCache = {}
-
-function renderTemplate(templatePath, data) {
-    if (rendererCache[templatePath]) {
-        return rendererCache[templatePath](data)
-    }
-    const templateContent = fs.readFileSync(templatePath, 'utf8')
-    const renderer = ejs.compile(templateContent)
-    rendererCache[templatePath] = renderer
-    return renderer(data)
-}
-
-function executePlan(ctx) {
-    const { plan } = ctx
-    for (const step of plan) {
-        switch (step.command) {
-            case 'copy':
-                fs.cpSync(step.input, step.output, { recursive: true })
-                break
-            case 'render': {
-                const { getData, template, output } = step
-                const data = getData()
-                console.log(data)
-                fs.mkdirSync(path.dirname(output), { recursive: true, force: true })
-                fs.writeFileSync(output, renderTemplate(template, { ctx: data }))
-                break
-            }
-        }
-    }
-    return ctx
-}
-
-module.exports = executePlan

package/src/load-spec.js

@@ -1,9 +0,0 @@
-module.exports = function loadSpec(ctx) {
-    const { request } = ctx
-    const { specPath } = request
-    const spec = require(specPath)
-    return {
-        ...ctx,
-        spec,
-    }
-}

package/src/main.js

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-
-const buildIr = require('./build-ir')
-const dispatchBuildPlan = require('./build-plan')
-const buildRequest = require('./build-request')
-const executePlan = require('./execute-plan')
-const loadSpec = require('./load-spec')
-const parseInput = require('./parse-input')
-const prepareOutput = require('./prepare-output')
-
-const Pipeline = [
-    parseInput,
-    buildRequest,
-    prepareOutput,
-    loadSpec,
-    buildIr,
-    dispatchBuildPlan,
-    executePlan,
-]
-
-function main() {
-    return Pipeline.reduce(
-        (acc, step) => {
-            return step(acc)
-        },
-        { argv: process.argv }
-    )
-}
-
-console.log(JSON.stringify(main(), null, 2))

package/src/parse-input.js

@@ -1,49 +0,0 @@
-const yargs = require('yargs')
-const { hideBin } = require('yargs/helpers')
-
-module.exports = function parseInput(ctx) {
-    const args = yargs(hideBin(ctx.argv))
-        .scriptName('sdkgen')
-        .version(false)
-        .option('spec', {
-            type: 'string',
-            description: 'The path to the OpenWS spec file',
-        })
-        .option('out', {
-            type: 'string',
-            description: 'The path to the output directory',
-        })
-        .option('project', {
-            type: 'string',
-            description: 'The path to the project directory',
-        })
-        .option('hostRole', {
-            type: 'array',
-            description: 'The target participant roles that use the generated code',
-        })
-        .option('language', {
-            type: 'string',
-            description: 'The language to generate code for',
-            choices: ['csharp', 'javascript'],
-            default: 'csharp',
-        })
-        .option('environment', {
-            type: 'string',
-            description: 'The environments to generate code for',
-            choices: ['unity', 'node', 'browser'],
-            default: ['unity'],
-        })
-        .option('frameworks', {
-            type: 'array',
-            description: 'The frameworks to generate code for',
-            choices: ['fastify', 'newtonsoft'],
-        })
-        .strict()
-        .help()
-        .parse()
-
-    return {
-        ...ctx,
-        rawInput: args,
-    }
-}

package/src/prepare-output.js

@@ -1,12 +0,0 @@
-const fs = require('node:fs')
-
-// 1. Create / clear output directory
-// 2. Load OpenWS spec
-// 3. Generate plan
-module.exports = function prepareOutput(ctx) {
-    const { request } = ctx
-    const { outputPath } = request
-    fs.rmSync(outputPath, { recursive: true, force: true })
-    fs.mkdirSync(outputPath, { recursive: true })
-    return ctx
-}