@polytric/openws-sdkgen 0.0.2 → 0.0.4

package/dist/main.cjs

@@ -0,0 +1,426 @@
+#!/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
+));
+
+// 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/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
+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({
+  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_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: {
+      [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_path2 = __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_path2.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
+];
+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/main.d.cts

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

package/dist/main.d.ts

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