@polytric/openws-sdkgen 0.0.2 → 0.0.4

package/dist/main.js

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+
+// src/build-ir.ts
+import S from "@pocketgems/schema";
+var 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": {
+      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/build-plan.ts
+var planIndex = {
+  csharp: {
+    unity: "./plans/dotnet.js"
+  }
+};
+async 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 planPath = planIndex[language]?.[environment];
+  if (!planPath) throw new Error(`No plan for ${language}/${environment}`);
+  const { default: plan } = await import(planPath);
+  return plan(ctx);
+}
+
+// src/build-request.ts
+import path from "path";
+import process2 from "process";
+import S2 from "@pocketgems/schema";
+var validateBuildRequest = S2.obj({
+  specPath: S2.str,
+  outputPath: S2.str,
+  project: S2.str,
+  hostRoles: S2.arr(S2.str),
+  target: S2.obj({
+    csharp: S2.obj({
+      environment: S2.str.enum("unity"),
+      frameworks: S2.arr(S2.str.enum("newtonsoft")).optional()
+    }).optional(),
+    javascript: S2.obj({
+      environment: S2.str.enum("node", "browser"),
+      frameworks: S2.arr(S2.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: path.join(process2.cwd(), rawInput.spec),
+    outputPath: path.join(process2.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
+import fs from "fs";
+import path2 from "path";
+import ejs from "ejs";
+var 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;
+  if (!plan) throw new Error("plan is required");
+  for (const step of plan) {
+    switch (step.command) {
+      case "copy":
+        if (step.input) {
+          fs.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);
+        fs.mkdirSync(path2.dirname(output), { recursive: true });
+        fs.writeFileSync(output, renderTemplate(template, { ctx: data }));
+        break;
+      }
+    }
+  }
+  return ctx;
+}
+
+// src/load-spec.ts
+import fs2 from "fs";
+function loadSpec(ctx) {
+  const { request } = ctx;
+  if (!request) throw new Error("request is required");
+  const { specPath } = request;
+  const spec = JSON.parse(fs2.readFileSync(specPath, "utf8"));
+  return {
+    ...ctx,
+    spec
+  };
+}
+
+// src/parse-input.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+function parseInput(ctx) {
+  const args = yargs(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
+import fs3 from "fs";
+function prepareOutput(ctx) {
+  const { request } = ctx;
+  if (!request) throw new Error("request is required");
+  const { outputPath } = request;
+  fs3.rmSync(outputPath, { recursive: true, force: true });
+  fs3.mkdirSync(outputPath, { recursive: true });
+  return ctx;
+}
+
+// src/main.ts
+var Pipeline = [
+  parseInput,
+  buildRequest,
+  prepareOutput,
+  loadSpec,
+  buildIr,
+  dispatchBuildPlan,
+  executePlan
+];
+async function main() {
+  let ctx = { argv: process.argv };
+  for (const step of Pipeline) {
+    ctx = await step(ctx);
+  }
+  return ctx;
+}
+main().then((result) => {
+  console.log(JSON.stringify(result, null, 2));
+}).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/plans/dotnet.cjs

@@ -0,0 +1,229 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plans/dotnet.ts
+var dotnet_exports = {};
+__export(dotnet_exports, {
+  default: () => createPlan
+});
+module.exports = __toCommonJS(dotnet_exports);
+
+// ../../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/plans/dotnet.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));
+var TEMPLATE_DIR = import_node_path.default.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: import_node_path.default.join(TEMPLATE_DIR, "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(TEMPLATE_DIR, "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(TEMPLATE_DIR, "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(TEMPLATE_DIR, "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(TEMPLATE_DIR, "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(TEMPLATE_DIR, "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(TEMPLATE_DIR, "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";
+  }
+}