@polytric/openws-sdkgen 0.0.3 → 0.0.4

package/dist/main.cjs

@@ -23,10 +23,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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({
@@ -238,215 +234,27 @@ function buildIr(ctx) {
   };
 }
 
-// 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
+    unity: "./plans/dotnet.js"
   }
 };
-function dispatchBuildPlan(ctx) {
+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 plan = planIndex[language]?.[environment];
-  if (!plan) throw new Error(`No plan for ${language}/${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
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path = __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({
@@ -470,8 +278,8 @@ function buildRequest(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),
+    specPath: import_node_path.default.join(import_node_process.default.cwd(), rawInput.spec),
+    outputPath: import_node_path.default.join(import_node_process.default.cwd(), rawInput.out),
     project: rawInput.project,
     hostRoles: rawInput.hostRole,
     target: {
@@ -490,7 +298,7 @@ function buildRequest(ctx) {
 
 // src/execute-plan.ts
 var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 var import_ejs = __toESM(require("ejs"), 1);
 var rendererCache = {};
 function renderTemplate(templatePath, data) {
@@ -517,7 +325,7 @@ function executePlan(ctx) {
         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.mkdirSync(import_node_path2.default.dirname(output), { recursive: true });
         import_node_fs.default.writeFileSync(output, renderTemplate(template, { ctx: data }));
         break;
       }
@@ -603,7 +411,16 @@ var Pipeline = [
   dispatchBuildPlan,
   executePlan
 ];
-function main() {
-  return Pipeline.reduce((acc, step) => step(acc), { argv: process.argv });
+async function main() {
+  let ctx = { argv: process.argv };
+  for (const step of Pipeline) {
+    ctx = await step(ctx);
+  }
+  return ctx;
 }
-console.log(JSON.stringify(main(), null, 2));
+main().then((result) => {
+  console.log(JSON.stringify(result, null, 2));
+}).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/main.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/main.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

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);
+});