@polytric/openws-sdkgen 0.0.3 → 0.0.4

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

package/dist/plans/dotnet.d.cts

@@ -0,0 +1,147 @@
+interface PipelineContext {
+    argv: string[];
+    rawInput?: RawInput;
+    request?: BuildRequest;
+    spec?: OpenWsSpec;
+    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 OpenWsSpec {
+    name: string;
+    description?: string;
+    version?: string;
+    networks: Record<string, NetworkSpec>;
+}
+interface NetworkSpec {
+    name: string;
+    description?: string;
+    version?: string;
+    roles: Record<string, RoleSpec>;
+}
+interface RoleSpec {
+    name: string;
+    description?: string;
+    endpoints?: Endpoint[];
+    messages: Record<string, MessageSpec>;
+}
+interface Endpoint {
+    scheme: 'ws' | 'wss';
+    host: string;
+    port: number;
+    path: string;
+}
+interface MessageSpec {
+    description?: string;
+    from?: string[];
+    payload: JsonSchema;
+}
+interface JsonSchema {
+    type: string;
+    description?: string;
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema;
+    required?: 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,147 @@
+interface PipelineContext {
+    argv: string[];
+    rawInput?: RawInput;
+    request?: BuildRequest;
+    spec?: OpenWsSpec;
+    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 OpenWsSpec {
+    name: string;
+    description?: string;
+    version?: string;
+    networks: Record<string, NetworkSpec>;
+}
+interface NetworkSpec {
+    name: string;
+    description?: string;
+    version?: string;
+    roles: Record<string, RoleSpec>;
+}
+interface RoleSpec {
+    name: string;
+    description?: string;
+    endpoints?: Endpoint[];
+    messages: Record<string, MessageSpec>;
+}
+interface Endpoint {
+    scheme: 'ws' | 'wss';
+    host: string;
+    port: number;
+    path: string;
+}
+interface MessageSpec {
+    description?: string;
+    from?: string[];
+    payload: JsonSchema;
+}
+interface JsonSchema {
+    type: string;
+    description?: string;
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema;
+    required?: 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);
+      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: 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
+};