@polytric/openws-sdkgen 0.0.5 → 0.0.6

package/dist/plans/typescript.js

@@ -0,0 +1,532 @@
+// src/plans/typescript.ts
+import path from "path";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var TEMPLATE_DIR = path.join(__dirname, "../templates/typescript");
+var SRC_TEMPLATE_DIR = path.join(TEMPLATE_DIR, "src");
+var CORE_TEMPLATE_DIR = path.join(SRC_TEMPLATE_DIR, "core");
+var ROLES_TEMPLATE_DIR = path.join(CORE_TEMPLATE_DIR, "roles");
+var MODELS_TEMPLATE_DIR = path.join(CORE_TEMPLATE_DIR, "models");
+var SDK_TEMPLATE_DIR = path.join(SRC_TEMPLATE_DIR, "sdk");
+function pascalCase(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function camelCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function kebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+function createPlan(ctx) {
+  const { ir, request, spec } = ctx;
+  if (!ir) throw new Error("ir is required");
+  if (!request) throw new Error("request is required");
+  if (!spec) throw new Error("spec is required");
+  const language = Object.keys(request.target)[0];
+  const isTypeScript = language === "typescript";
+  const extension = isTypeScript ? "ts" : "js";
+  const packageName = `@${kebabCase(ir.package.project)}/${kebabCase(ir.package.service)}-openws-sdk`;
+  const plan = [
+    {
+      name: `${language} package manifest`,
+      command: "render",
+      getData: () => ({
+        isTypeScript,
+        packageName,
+        description: ir.package.description,
+        version: ir.package.version ?? "0.0.0",
+        extension
+      }),
+      template: path.join(TEMPLATE_DIR, "package.json.ejs"),
+      output: path.join(request.outputPath, "package.json")
+    }
+  ];
+  if (isTypeScript) {
+    plan.push(
+      {
+        name: `${language} tsconfig`,
+        command: "render",
+        getData: () => ({}),
+        template: path.join(TEMPLATE_DIR, "tsconfig.json.ejs"),
+        output: path.join(request.outputPath, "tsconfig.json")
+      },
+      {
+        name: `${language} tsup config`,
+        command: "render",
+        getData: () => ({}),
+        template: path.join(TEMPLATE_DIR, "tsup.config.ts.ejs"),
+        output: path.join(request.outputPath, "tsup.config.ts")
+      }
+    );
+  }
+  const networkExports = [];
+  for (const [networkName, networkSpec] of Object.entries(spec.networks)) {
+    const networkFileName = kebabCase(networkName);
+    const networkOutputPath = path.join(request.outputPath, "src", networkFileName);
+    const sdkOutputPath = path.join(request.outputPath, "src", "sdk");
+    const allRoles = Object.values(networkSpec.roles).map(toRoleInfo);
+    const rolesByName = new Map(allRoles.map((role) => [role.roleName, role]));
+    const hostRoles = allRoles;
+    const modelScopes = buildModelScopes(buildSpecModels(networkSpec));
+    networkExports.push({
+      exportName: camelCase(networkName),
+      fileName: networkFileName
+    });
+    plan.push({
+      name: `${language} network ${networkName}`,
+      command: "render",
+      getData: () => ({
+        isTypeScript,
+        networkName,
+        networkClassName: `${pascalCase(networkName)}Network`,
+        description: networkSpec.description,
+        version: networkSpec.version,
+        hostRoles,
+        allRoles,
+        extension
+      }),
+      template: path.join(CORE_TEMPLATE_DIR, "network.ts.ejs"),
+      output: path.join(networkOutputPath, `network.${extension}`)
+    });
+    plan.push({
+      name: `${language} network exports ${networkName}`,
+      command: "render",
+      getData: () => ({
+        isTypeScript,
+        extension,
+        modelScopes
+      }),
+      template: path.join(CORE_TEMPLATE_DIR, "index.ts.ejs"),
+      output: path.join(networkOutputPath, `index.${extension}`)
+    });
+    const roleMessagesByName = /* @__PURE__ */ new Map();
+    for (const role of allRoles) {
+      const roleSpec = networkSpec.roles[role.roleName];
+      const messages = Object.entries(roleSpec.messages).map(
+        ([messageName, messageSpec]) => toMessageInfo(messageName, messageSpec, rolesByName)
+      );
+      roleMessagesByName.set(role.roleName, messages);
+    }
+    const rolesWithMessages = allRoles.map((role) => ({
+      ...role,
+      messages: roleMessagesByName.get(role.roleName) ?? []
+    }));
+    for (const role of rolesWithMessages) {
+      plan.push({
+        name: `${language} core role ${role.className}`,
+        command: "render",
+        getData: () => ({
+          isTypeScript,
+          extension,
+          peerRoles: allRoles.filter((peerRole) => peerRole.roleName !== role.roleName),
+          ...role
+        }),
+        template: path.join(ROLES_TEMPLATE_DIR, "role.ts.ejs"),
+        output: path.join(networkOutputPath, "roles", `${role.fileName}.${extension}`)
+      });
+    }
+    plan.push({
+      name: `${language} core role exports ${networkName}`,
+      command: "render",
+      getData: () => ({
+        isTypeScript,
+        extension,
+        roles: allRoles
+      }),
+      template: path.join(ROLES_TEMPLATE_DIR, "index.ts.ejs"),
+      output: path.join(networkOutputPath, "roles", `index.${extension}`)
+    });
+    for (const modelScope of modelScopes) {
+      plan.push({
+        name: `${language} model exports ${modelScope.scopeName}`,
+        command: "render",
+        getData: () => ({
+          isTypeScript,
+          extension,
+          ...modelScope
+        }),
+        template: path.join(MODELS_TEMPLATE_DIR, "index.ts.ejs"),
+        output: path.join(
+          networkOutputPath,
+          "models",
+          modelScope.fileName,
+          `index.${extension}`
+        )
+      });
+      for (const model of modelScope.models) {
+        plan.push({
+          name: `${language} model ${model.className}`,
+          command: "render",
+          getData: () => ({
+            isTypeScript,
+            ...model
+          }),
+          template: path.join(MODELS_TEMPLATE_DIR, "model.ts.ejs"),
+          output: path.join(
+            networkOutputPath,
+            "models",
+            modelScope.fileName,
+            `${model.fileName}.${extension}`
+          )
+        });
+      }
+    }
+    for (const hostRole of hostRoles) {
+      const remoteRoles = getPeerRoles(networkSpec, rolesByName, hostRole.roleName).map(
+        (remoteRole) => ({
+          ...remoteRole,
+          scopedApiName: `${hostRole.className}${remoteRole.className}Api`,
+          allowedMethodNames: getAllowedMessageMethodNames(
+            networkSpec,
+            remoteRole.roleName,
+            hostRole.roleName
+          )
+        })
+      );
+      const roleSpec = networkSpec.roles[hostRole.roleName];
+      const roleHandlers = Object.entries(roleSpec.messages).map(
+        ([messageName, messageSpec]) => toHandlerInfo(
+          messageName,
+          messageSpec,
+          rolesByName,
+          hostRole.roleName,
+          allRoles
+        )
+      );
+      plan.push({
+        name: `${language} sdk role ${hostRole.className}`,
+        command: "render",
+        getData: () => ({
+          isTypeScript,
+          extension,
+          handlers: roleHandlers,
+          networkName,
+          networkDescription: networkSpec.description,
+          networkVersion: networkSpec.version,
+          remoteRoles,
+          ...hostRole
+        }),
+        template: path.join(SDK_TEMPLATE_DIR, "role.ts.ejs"),
+        output: path.join(sdkOutputPath, `${hostRole.fileName}.${extension}`)
+      });
+    }
+    plan.push({
+      name: `${language} sdk exports ${networkName}`,
+      command: "render",
+      getData: () => ({
+        isTypeScript,
+        extension,
+        roles: hostRoles
+      }),
+      template: path.join(SDK_TEMPLATE_DIR, "index.ts.ejs"),
+      output: path.join(sdkOutputPath, `index.${extension}`)
+    });
+  }
+  plan.push({
+    name: `${language} package exports`,
+    command: "render",
+    getData: () => ({
+      isTypeScript,
+      extension,
+      networkExports
+    }),
+    template: path.join(SRC_TEMPLATE_DIR, "index.ts.ejs"),
+    output: path.join(request.outputPath, "src", `index.${extension}`)
+  });
+  return {
+    ...ctx,
+    plan
+  };
+}
+function buildModelScopes(models) {
+  const scopes = /* @__PURE__ */ new Map();
+  const objectModels = models.filter((model) => model.type === "object");
+  for (const model of objectModels) {
+    const scopeName = model.scopeName;
+    const scope = scopes.get(scopeName) ?? {
+      scopeName,
+      className: pascalCase(scopeName),
+      varName: camelCase(scopeName),
+      fileName: kebabCase(scopeName),
+      models: []
+    };
+    scope.models.push({
+      scopeName,
+      className: pascalCase(model.modelName),
+      fileName: kebabCase(model.modelName),
+      schema: buildModelSchema(model, objectModels),
+      properties: (model.properties ?? []).map((property) => ({
+        name: property.modelName,
+        optional: !property.required,
+        typeName: mapType(property)
+      })),
+      imports: buildModelImports(model)
+    });
+    scopes.set(scopeName, scope);
+  }
+  return [...scopes.values()];
+}
+function toRoleInfo(role) {
+  const className = pascalCase(role.name);
+  const fileName = kebabCase(role.name);
+  return {
+    roleName: role.name,
+    className,
+    roleClassName: className,
+    hostRoleClassName: `${className}Host`,
+    apiName: `${className}Api`,
+    varName: camelCase(role.name),
+    apiVarName: `${camelCase(role.name)}Api`,
+    fileName,
+    roleFileName: `${fileName}-role`,
+    description: role.description || "",
+    endpoints: role.endpoints || []
+  };
+}
+function getMessageFromRoles(message, rolesByName, currentRoleName, allRoles) {
+  const fromRoleNames = getMessageFromRoleNames(
+    message,
+    currentRoleName,
+    allRoles.map((role) => role.roleName)
+  );
+  return fromRoleNames.map((roleName) => rolesByName.get(roleName)).filter((role) => Boolean(role));
+}
+function getExplicitMessageFromRoles(message, rolesByName) {
+  if (!message.from) return void 0;
+  return message.from.map((roleName) => rolesByName.get(roleName)).filter((role) => Boolean(role));
+}
+function getPeerRoles(network, rolesByName, hostRoleName) {
+  const peers = /* @__PURE__ */ new Set();
+  const hostRole = network.roles[hostRoleName];
+  const allRoleNames = Object.keys(network.roles);
+  for (const message of Object.values(hostRole.messages)) {
+    for (const roleName of getMessageFromRoleNames(message, hostRoleName, allRoleNames)) {
+      peers.add(roleName);
+    }
+  }
+  for (const [roleName, role] of Object.entries(network.roles)) {
+    if (roleName === hostRoleName) continue;
+    for (const message of Object.values(role.messages)) {
+      if (getMessageFromRoleNames(message, roleName, allRoleNames).includes(hostRoleName)) {
+        peers.add(roleName);
+      }
+    }
+  }
+  return [...peers].map((roleName) => rolesByName.get(roleName)).filter((role) => Boolean(role));
+}
+function getMessageFromRoleNames(message, targetRoleName, allRoleNames) {
+  return message.from ?? allRoleNames.filter((roleName) => roleName !== targetRoleName);
+}
+function getAllowedMessageMethodNames(network, targetRoleName, fromRoleName) {
+  const targetRole = network.roles[targetRoleName];
+  const allRoleNames = Object.keys(network.roles);
+  return Object.entries(targetRole.messages).filter(
+    ([, message]) => getMessageFromRoleNames(message, targetRoleName, allRoleNames).includes(fromRoleName)
+  ).map(([messageName]) => camelCase(messageName));
+}
+function buildSpecModels(network) {
+  const models = [];
+  for (const role of Object.values(network.roles)) {
+    for (const [messageName, message] of Object.entries(role.messages)) {
+      models.push(...buildIrModels(role.name, `${messageName}Payload`, message.payload));
+    }
+  }
+  return models;
+}
+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": {
+      const items = schema.items;
+      if (!items) return [];
+      return buildIrModels(scopeName, modelName, items);
+    }
+    case "object": {
+      const properties = [];
+      model.properties = properties;
+      const models = [];
+      const schemaProperties = schema.properties;
+      if (!schemaProperties) return [model];
+      for (const [subName, subSchema] of Object.entries(schemaProperties)) {
+        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 buildModelImports(model) {
+  const imports = /* @__PURE__ */ new Map();
+  const addImport = (modelName) => {
+    if (!modelName || modelName === model.modelName) return;
+    const className = pascalCase(modelName);
+    imports.set(className, {
+      className,
+      fileName: kebabCase(modelName)
+    });
+  };
+  for (const property of model.properties ?? []) {
+    if (property.type === "object") {
+      addImport(property.modelName);
+    }
+    if (property.type === "array" && property.items?.type === "object") {
+      addImport(property.items.modelName);
+    }
+  }
+  return [...imports.values()];
+}
+function buildModelSchema(model, models, seen = /* @__PURE__ */ new Set()) {
+  const key = `${model.scopeName}:${model.modelName}`;
+  if (seen.has(key)) return { type: "object" };
+  const nextSeen = new Set(seen);
+  nextSeen.add(key);
+  const properties = {};
+  const required = [];
+  for (const property of model.properties ?? []) {
+    properties[property.modelName] = buildPropertySchema(property, models, nextSeen);
+    if (property.required) required.push(property.modelName);
+  }
+  const schema = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    type: "object",
+    properties,
+    additionalProperties: false
+  };
+  if (model.description) schema.description = model.description;
+  if (required.length > 0) schema.required = required;
+  return schema;
+}
+function buildNestedObjectSchema(model, models, seen) {
+  const { $schema: _schema, ...schema } = buildModelSchema(model, models, seen);
+  return schema;
+}
+function buildPropertySchema(property, models, seen) {
+  const schema = buildSchemaForType(
+    property.type,
+    property.scopeName,
+    property.modelName,
+    models,
+    seen
+  );
+  if (property.description) schema.description = property.description;
+  if (property.type === "array" && property.items) {
+    schema.items = buildSchemaForType(
+      property.items.type,
+      property.items.scopeName,
+      property.items.modelName,
+      models,
+      seen
+    );
+    if (property.items.description && typeof schema.items === "object" && schema.items !== null) {
+      const itemSchema = schema.items;
+      itemSchema.description = property.items.description;
+    }
+  }
+  return schema;
+}
+function buildSchemaForType(type, scopeName, modelName, models, seen) {
+  switch (type) {
+    case "string":
+    case "number":
+    case "integer":
+    case "boolean":
+    case "null":
+      return { type };
+    case "array":
+      return { type: "array" };
+    case "object": {
+      const model = findModel(models, scopeName, modelName);
+      if (!model) return { type: "object" };
+      return buildNestedObjectSchema(model, models, seen);
+    }
+    default:
+      return {};
+  }
+}
+function findModel(models, scopeName, modelName) {
+  return models.find((model) => model.scopeName === scopeName && model.modelName === modelName);
+}
+function toHandlerInfo(messageName, message, rolesByName, _currentRoleName, _allRoles) {
+  const payloadType = pascalCase(messageName) + "Payload";
+  const methodSuffix = pascalCase(messageName);
+  return {
+    dispatchMethodName: camelCase(messageName),
+    onMethodName: `on${methodSuffix}`,
+    listenerFieldName: `${camelCase(messageName)}Handlers`,
+    messageName,
+    payloadType,
+    payloadFileName: kebabCase(payloadType),
+    schema: toJsonValue(message.payload),
+    fromRoles: getExplicitMessageFromRoles(message, rolesByName),
+    bindFromRoles: getMessageFromRoles(message, rolesByName, _currentRoleName, _allRoles)
+  };
+}
+function toMessageInfo(messageName, message, rolesByName) {
+  const payloadType = pascalCase(messageName) + "Payload";
+  return {
+    methodName: camelCase(messageName),
+    messageName,
+    payloadType,
+    payloadFileName: kebabCase(payloadType),
+    schema: toJsonValue(message.payload),
+    fromRoles: getExplicitMessageFromRoles(message, rolesByName)
+  };
+}
+function toJsonValue(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function mapType(property) {
+  switch (property.type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "array":
+      if (!property.items) return "unknown[]";
+      return `${mapType(property.items)}[]`;
+    case "object":
+      return pascalCase(property.modelName);
+    default:
+      return "unknown";
+  }
+}
+export {
+  createPlan as default
+};

package/dist/templates/typescript/package.json.ejs

@@ -0,0 +1,41 @@
+{
+    "name": <%- JSON.stringify(ctx.packageName) %>,
+    "version": <%- JSON.stringify(ctx.version) %>,
+    "description": <%- JSON.stringify(ctx.description ?? '') %>,
+    "type": "module",
+<% if (ctx.isTypeScript) { -%>
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "dependencies": {
+        "@polytric/openws": "^0.0.4"
+    },
+    "scripts": {
+        "build": "tsup",
+        "typecheck": "tsc --noEmit"
+    },
+    "devDependencies": {
+        "tsup": "^8.5.1",
+        "typescript": "^5.9.3"
+    }
+<% } else { -%>
+    "main": "./src/index.js",
+    "exports": {
+        ".": "./src/index.js"
+    },
+    "files": [
+        "src"
+    ],
+    "dependencies": {
+        "@polytric/openws": "^0.0.4"
+    }
+<% } -%>
+}

package/dist/templates/typescript/src/core/index.ts.ejs

@@ -0,0 +1,6 @@
+export * from './network<%= ctx.isTypeScript ? '' : '.js' %>'
+export * from './roles<%= ctx.isTypeScript ? '' : '/index.js' %>'
+export * as roles from './roles<%= ctx.isTypeScript ? '' : '/index.js' %>'
+<% for (const modelScope of ctx.modelScopes) { -%>
+export * as <%= modelScope.varName %>Models from './models/<%= modelScope.fileName %><%= ctx.isTypeScript ? '' : '/index.js' %>'
+<% } -%>

package/dist/templates/typescript/src/core/models/index.ts.ejs

@@ -0,0 +1,3 @@
+<% for (const model of ctx.models) { -%>
+export * from './<%= model.fileName %><%= ctx.isTypeScript ? '' : '.js' %>'
+<% } -%>

package/dist/templates/typescript/src/core/models/model.ts.ejs

@@ -0,0 +1,41 @@
+<% if (ctx.isTypeScript) { -%>
+<% for (const modelImport of ctx.imports) { -%>
+import type { <%= modelImport.className %> } from './<%= modelImport.fileName %>'
+<% } -%>
+<% if (ctx.imports.length > 0) { -%>
+
+<% } -%>
+export interface <%= ctx.className %>Init {
+<% for (const property of ctx.properties) { -%>
+    <%= property.name %><%= property.optional ? '?' : '' %>: <%= property.typeName %>
+<% } -%>
+}
+
+export class <%= ctx.className %> implements <%= ctx.className %>Init {
+<% for (const property of ctx.properties) { -%>
+    readonly <%= property.name %><%= property.optional ? '?' : '' %>: <%= property.typeName %>
+<% } -%>
+
+    constructor({
+<% for (const property of ctx.properties) { -%>
+        <%= property.name %>,
+<% } -%>
+    }: <%= ctx.className %>Init = {} as <%= ctx.className %>Init) {
+<% for (const property of ctx.properties) { -%>
+        this.<%= property.name %> = <%= property.name %>
+<% } -%>
+    }
+}
+<% } else { -%>
+export class <%= ctx.className %> {
+    constructor({
+<% for (const property of ctx.properties) { -%>
+        <%= property.name %>,
+<% } -%>
+    } = {}) {
+<% for (const property of ctx.properties) { -%>
+        this.<%= property.name %> = <%= property.name %>
+<% } -%>
+    }
+}
+<% } -%>