typespec-rust-emitter 0.1.0 → 0.2.0

package/src/emitter.ts

@@ -21,6 +21,8 @@ import {
   StringLiteral,
   DecoratorContext,
   getNamespaceFullName,
+  Operation,
+  getTags,
 } from "@typespec/compiler";
 
 export interface RustEmitterOptions {
@@ -73,6 +75,716 @@ export function $rustDerives(
   }
 }
 
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
+
+interface OperationInfo {
+  name: string;
+  method: HttpMethod;
+  path: string;
+  tags: string[];
+  parameters: ParameterInfo[];
+  body: ModelProperty | undefined;
+  responses: ResponseInfo[];
+  doc: string | undefined;
+}
+
+interface ParameterInfo {
+  name: string;
+  rustName: string;
+  rustType: string;
+  location: "path" | "query" | "header" | "cookie";
+  required: boolean;
+  optional?: boolean;
+}
+
+interface ResponseInfo {
+  statusCode: number;
+  bodyType: string | undefined;
+  bodyDescription: string | undefined;
+}
+
+function getDecoratorName(decorator: any): string {
+  if (!decorator) return "";
+  if (typeof decorator !== "object") return "";
+
+  if (decorator.node?.target?.sv) {
+    return decorator.node.target.sv;
+  }
+  if (
+    decorator.node?.target?.kind === "Identifier" &&
+    decorator.node?.target?.sv
+  ) {
+    return decorator.node.target.sv;
+  }
+
+  return "";
+}
+
+function getDecoratorArgValue(decorator: any, index: number = 0): string {
+  if (!decorator) return "";
+  const args = decorator.args || decorator.arguments;
+  if (!args) return "";
+  const arg = args[index];
+  if (arg?.jsValue !== undefined) return String(arg.jsValue);
+  if (arg?.value !== undefined) return String(arg.value);
+  return "";
+}
+
+function getHttpMethod(
+  _program: Program,
+  operation: Operation,
+): HttpMethod | undefined {
+  const decorators = (operation as any).decorators;
+  if (!decorators) return undefined;
+
+  for (const key of Object.keys(decorators)) {
+    const decorator = decorators[key];
+    const name = getDecoratorName(decorator);
+    if (name === "get") return "GET";
+    if (name === "post") return "POST";
+    if (name === "put") return "PUT";
+    if (name === "patch") return "PATCH";
+    if (name === "delete") return "DELETE";
+    if (name === "head") return "HEAD";
+  }
+  return undefined;
+}
+
+function getRoute(_program: Program, target: Namespace | Operation): string {
+  const decorators = (target as any).decorators;
+  if (!decorators) return "";
+
+  for (const key of Object.keys(decorators)) {
+    const decorator = decorators[key];
+    const name = getDecoratorName(decorator);
+    if (name === "route") {
+      return getDecoratorArgValue(decorator, 0);
+    }
+  }
+  return "";
+}
+
+function hasAuthDecorator(operation: Operation): boolean {
+  const decorators = (operation as any).decorators;
+  if (!decorators) return false;
+
+  for (const key of Object.keys(decorators)) {
+    const decorator = decorators[key];
+    const name = getDecoratorName(decorator);
+    if (name === "useAuth") {
+      return true;
+    }
+  }
+  return false;
+}
+
+function getOperationParameters(
+  program: Program,
+  operation: Operation,
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): ParameterInfo[] {
+  const params: ParameterInfo[] = [];
+  const model = operation.parameters;
+
+  for (const [propName, prop] of model.properties) {
+    const decorators = (prop as any).decorators;
+    let location: "path" | "query" | "header" | "cookie" = "query";
+    let rustName = toRustIdent(propName);
+
+    if (decorators) {
+      if (decorators["$path"]) {
+        location = "path";
+      } else if (decorators["$query"]) {
+        location = "query";
+      } else if (decorators["$header"]) {
+        location = "header";
+        const headerDec = decorators["$header"];
+        if (headerDec?.value) {
+          rustName = headerDec.value;
+        }
+      } else if (decorators["$cookie"]) {
+        location = "cookie";
+      }
+    }
+
+    const { type: rustType } = getRustTypeForProperty(
+      prop.type,
+      program,
+      anonymousEnums,
+    );
+
+    params.push({
+      name: propName,
+      rustName,
+      rustType,
+      location,
+      required: !prop.optional,
+      optional: prop.optional,
+    });
+  }
+
+  return params;
+}
+
+function getOperationBody(operation: Operation): ModelProperty | undefined {
+  for (const [_propName, prop] of operation.parameters.properties) {
+    const decorators = (prop as any).decorators;
+    if (decorators?.["$body"] || decorators?.["$bodyRoot"]) {
+      return prop;
+    }
+  }
+  return undefined;
+}
+
+function getOperationResponses(
+  program: Program,
+  operation: Operation,
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): ResponseInfo[] {
+  const responses: ResponseInfo[] = [];
+  const returnType = operation.returnType;
+
+  if (returnType.kind === "Union") {
+    const union = returnType as Union;
+    for (const variant of union.variants.values()) {
+      const statusCode = getStatusCode(variant);
+      const bodyInfo = getBodyFromResponse(variant, program, anonymousEnums);
+      responses.push({
+        statusCode,
+        bodyType: bodyInfo.type,
+        bodyDescription: bodyInfo.description,
+      });
+    }
+  } else if (returnType.kind === "Model") {
+    const model = returnType as Model;
+    for (const [propName, prop] of model.properties) {
+      if (propName === "body") {
+        const { type: rustType } = getRustTypeForProperty(
+          prop.type,
+          program,
+          anonymousEnums,
+        );
+        responses.push({
+          statusCode: 200,
+          bodyType: rustType,
+          bodyDescription: getDoc(program, prop),
+        });
+      }
+    }
+  }
+
+  return responses;
+}
+
+function getStatusCode(variant: { type: Type }): number {
+  if (variant.type.kind === "Model") {
+    const model = variant.type as Model;
+    for (const [propName, prop] of model.properties) {
+      if (propName === "statusCode") {
+        const typeAny = prop.type as any;
+        if (typeAny.value !== undefined) {
+          return typeAny.value as number;
+        }
+      }
+    }
+  }
+  return 200;
+}
+
+function getBodyFromResponse(
+  variant: { type: Type },
+  program: Program,
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): { type: string | undefined; description: string | undefined } {
+  if (variant.type.kind === "Model") {
+    const model = variant.type as Model;
+    for (const [propName, prop] of model.properties) {
+      if (propName === "body") {
+        const { type: rustType } = getRustTypeForProperty(
+          prop.type,
+          program,
+          anonymousEnums,
+        );
+        return { type: rustType, description: getDoc(program, prop) };
+      }
+    }
+  }
+  return { type: undefined, description: undefined };
+}
+
+function getAllOperations(
+  program: Program,
+): { namespace: Namespace; operations: Operation[] }[] {
+  const seenNamespaces = new Set<string>();
+  const namespaceOps = new Map<string, { ns: Namespace; ops: Operation[] }>();
+
+  navigateProgram(program, {
+    namespace(ns: Namespace) {
+      const route = getRoute(program, ns);
+      if (!route) return;
+      if (!seenNamespaces.has(ns.name)) {
+        seenNamespaces.add(ns.name);
+        namespaceOps.set(ns.name, { ns, ops: [] });
+      }
+    },
+    operation(op: Operation) {
+      const method = getHttpMethod(program, op);
+      if (!method) return;
+      const ns = op.namespace;
+      if (!ns) return;
+      if (!seenNamespaces.has(ns.name)) {
+        seenNamespaces.add(ns.name);
+        namespaceOps.set(ns.name, { ns, ops: [] });
+      }
+      const entry = namespaceOps.get(ns.name);
+      if (entry) {
+        entry.ops.push(op);
+      }
+    },
+  });
+
+  const result: { namespace: Namespace; operations: Operation[] }[] = [];
+  for (const [, entry] of namespaceOps) {
+    if (entry.ops.length > 0) {
+      result.push({ namespace: entry.ns, operations: entry.ops });
+    }
+  }
+  return result;
+}
+
+function buildFullPath(namespaceRoute: string, operationRoute: string): string {
+  let fullPath = namespaceRoute + operationRoute;
+  fullPath = fullPath.replace(/\/+/g, "/");
+  if (fullPath.length > 1 && fullPath.endsWith("/")) {
+    fullPath = fullPath.slice(0, -1);
+  }
+  return fullPath;
+}
+
+function emitOperationInfo(
+  program: Program,
+  op: Operation,
+  nsRoute: string,
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): OperationInfo | undefined {
+  const method = getHttpMethod(program, op);
+  if (!method) return undefined;
+
+  const opRoute = getRoute(program, op);
+  const fullPath = buildFullPath(nsRoute, opRoute);
+  const tags = getTags(program, op) ?? [];
+  const params = getOperationParameters(program, op, anonymousEnums);
+  const body = getOperationBody(op);
+  const responses = getOperationResponses(program, op, anonymousEnums);
+  const doc = getDoc(program, op);
+
+  const opName = op.name.replace(/[^a-zA-Z0-9_]/g, "_");
+
+  return {
+    name: opName,
+    method,
+    path: fullPath,
+    tags,
+    parameters: params,
+    body: body,
+    responses,
+    doc,
+  };
+}
+
+function getStatusVariantName(statusCode: number): string {
+  const statusNames: Record<number, string> = {
+    200: "Ok",
+    201: "Created",
+    202: "Accepted",
+    204: "NoContent",
+    400: "BadRequest",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "NotFound",
+    409: "Conflict",
+    500: "InternalServerError",
+  };
+  return statusNames[statusCode] || `Status${statusCode}`;
+}
+
+function getHttpStatusCode(statusCode: number): string {
+  const statusCodes: Record<number, string> = {
+    200: "StatusCode::OK",
+    201: "StatusCode::CREATED",
+    202: "StatusCode::ACCEPTED",
+    204: "StatusCode::NO_CONTENT",
+    400: "StatusCode::BAD_REQUEST",
+    401: "StatusCode::UNAUTHORIZED",
+    403: "StatusCode::FORBIDDEN",
+    404: "StatusCode::NOT_FOUND",
+    409: "StatusCode::CONFLICT",
+    500: "StatusCode::INTERNAL_SERVER_ERROR",
+  };
+  return statusCodes[statusCode] || `StatusCode::from_u16(${statusCode})`;
+}
+
+function generateServerTrait(
+  program: Program,
+  namespaceGroups: { namespace: Namespace; operations: Operation[] }[],
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): string {
+  const parts: string[] = [];
+
+  parts.push(`use super::types::*;
+use async_trait::async_trait;
+use axum::{http::StatusCode, Json};
+use eyre::Result;
+
+#[async_trait]
+pub trait Server: Send + Sync {
+    type Claims: Send + Sync + 'static;
+
+`);
+
+  for (const group of namespaceGroups) {
+    const nsName = toPascalCase(
+      group.namespace.name.replace(/[^a-zA-Z0-9_]/g, "_"),
+    );
+
+    for (const op of group.operations) {
+      const opInfo = emitOperationInfo(program, op, "", anonymousEnums);
+      if (!opInfo) continue;
+
+      if (opInfo.doc) {
+        parts.push(`    ${formatDoc(opInfo.doc)}`);
+      }
+
+      const requestName = `${nsName}${toPascalCase(opInfo.name)}Request`;
+      const responseName = `${nsName}${toPascalCase(opInfo.name)}Response`;
+      const fnName = toRustIdent(`${nsName}_${opInfo.name}`);
+      const isProtected = hasAuthDecorator(op);
+
+      if (isProtected) {
+        parts.push(
+          `    async fn ${fnName}(&self, claims: Self::Claims, request: ${requestName}) -> Result<${responseName}>;`,
+        );
+      } else {
+        parts.push(
+          `    async fn ${fnName}(&self, request: ${requestName}) -> Result<${responseName}>;`,
+        );
+      }
+    }
+  }
+
+  parts.push("}");
+
+  return parts.join("\n");
+}
+
+function generateRequestStructs(
+  program: Program,
+  namespaceGroups: { namespace: Namespace; operations: Operation[] }[],
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): string {
+  const parts: string[] = [];
+
+  for (const group of namespaceGroups) {
+    const nsName = toPascalCase(
+      group.namespace.name.replace(/[^a-zA-Z0-9_]/g, "_"),
+    );
+
+    for (const op of group.operations) {
+      const opInfo = emitOperationInfo(program, op, "", anonymousEnums);
+      if (!opInfo) continue;
+
+      const params = opInfo.parameters;
+      const requestName = `${nsName}${toPascalCase(opInfo.name)}Request`;
+
+      const fields: string[] = [];
+
+      for (const param of params) {
+        const rustType = param.optional
+          ? `Option<${param.rustType}>`
+          : param.rustType;
+        fields.push(`  #[serde(rename = "${param.name}", flatten)]`);
+        fields.push(`  pub ${param.rustName}: ${rustType},`);
+      }
+
+      if (opInfo.body) {
+        const bodyType = getRustTypeForProperty(
+          opInfo.body.type,
+          program,
+          anonymousEnums,
+        );
+        fields.push(`  #[serde(rename = "body")]`);
+        fields.push(`  pub body: ${bodyType.type},`);
+      }
+
+      parts.push(`#[derive(Debug, Clone, serde::Deserialize)]
+pub struct ${requestName} {
+${fields.join("\n")}
+}
+`);
+    }
+  }
+
+  return parts.join("\n");
+}
+
+function generateResponseEnums(
+  program: Program,
+  namespaceGroups: { namespace: Namespace; operations: Operation[] }[],
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): string {
+  const parts: string[] = [];
+
+  for (const group of namespaceGroups) {
+    const nsName = toPascalCase(
+      group.namespace.name.replace(/[^a-zA-Z0-9_]/g, "_"),
+    );
+
+    for (const op of group.operations) {
+      const opInfo = emitOperationInfo(program, op, "", anonymousEnums);
+      if (!opInfo) continue;
+
+      if (opInfo.responses.length === 0) continue;
+
+      const responseName = `${nsName}${toPascalCase(opInfo.name)}Response`;
+
+      const variants: string[] = [];
+      for (const resp of opInfo.responses) {
+        const variantName = getStatusVariantName(resp.statusCode);
+        if (!resp.bodyType) {
+          variants.push(`    ${variantName},`);
+        } else {
+          variants.push(`    ${variantName}(Json<${resp.bodyType}>),`);
+        }
+      }
+      parts.push(`pub enum ${responseName} {
+${variants.join("\n")}
+}
+`);
+
+      parts.push(`impl IntoResponse for ${responseName} {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+`);
+      for (const resp of opInfo.responses) {
+        const variantName = getStatusVariantName(resp.statusCode);
+        const statusCodeStr = getHttpStatusCode(resp.statusCode);
+        if (!resp.bodyType) {
+          parts.push(
+            `            ${responseName}::${variantName} => ${statusCodeStr}.into_response(),`,
+          );
+        } else {
+          parts.push(
+            `            ${responseName}::${variantName}(body) => (${statusCodeStr}, body).into_response(),`,
+          );
+        }
+      }
+      parts.push(`        }
+    }
+}
+`);
+    }
+  }
+
+  return parts.join("\n");
+}
+
+function generateRouter(
+  program: Program,
+  namespaceGroups: { namespace: Namespace; operations: Operation[] }[],
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): string {
+  const handlers: string[] = [];
+  const publicRoutes: string[] = [];
+  const protectedRoutes: string[] = [];
+  const usedMethods = new Set<string>();
+
+  for (const group of namespaceGroups) {
+    const nsRoute = getRoute(program, group.namespace);
+    if (!nsRoute) continue;
+
+    const nsName = toPascalCase(
+      group.namespace.name.replace(/[^a-zA-Z0-9_]/g, "_"),
+    );
+
+    for (const op of group.operations) {
+      const opInfo = emitOperationInfo(program, op, nsRoute, anonymousEnums);
+      if (!opInfo) continue;
+
+      const method = opInfo.method.toLowerCase();
+      usedMethods.add(method);
+
+      const handlerFnName = toRustIdent(`${nsName}_${opInfo.name}`);
+      const traitFnName = handlerFnName;
+      const requestName = `${nsName}${toPascalCase(opInfo.name)}Request`;
+      const isProtected = hasAuthDecorator(op);
+
+      const pathParams = opInfo.parameters.filter((p) => p.location === "path");
+      const queryParams = opInfo.parameters.filter(
+        (p) => p.location === "query",
+      );
+      const hasPathParams = pathParams.length > 0;
+      const hasQueryParams = queryParams.length > 0;
+      const hasBody = !!opInfo.body;
+
+      // Build extractor lines and request construction expression
+      const extractorLines: string[] = [];
+      let requestExpr = "";
+
+      if (hasPathParams) {
+        const pathTypes = pathParams.map((p) => p.rustType).join(", ");
+        const pathFields = pathParams.map((p) => p.rustName).join(", ");
+        if (pathParams.length === 1) {
+          extractorLines.push(
+            `    axum::extract::Path(${pathFields}): axum::extract::Path<${pathTypes}>,`,
+          );
+        } else {
+          extractorLines.push(
+            `    axum::extract::Path((${pathFields})): axum::extract::Path<(${pathTypes})>,`,
+          );
+        }
+      }
+
+      if (hasQueryParams) {
+        extractorLines.push(
+          `    axum::extract::Query(query): axum::extract::Query<${requestName}>,`,
+        );
+      } else if (hasBody) {
+        extractorLines.push(
+          `    axum::Json(body): axum::Json<${requestName}Body>,`,
+        );
+      }
+
+      if (isProtected) {
+        extractorLines.push(
+          `    axum::Extension(claims): axum::Extension<S::Claims>,`,
+        );
+      }
+
+      // Build request struct expression
+      if (hasOnlyPathParams(hasPathParams, hasQueryParams, hasBody)) {
+        const pathAssignments = pathParams
+          .map((p) => `${p.rustName},`)
+          .join(" ");
+        requestExpr = `${requestName} { ${pathAssignments} }`;
+      } else if (hasQueryParams) {
+        if (hasPathParams) {
+          const pathAssignments = pathParams
+            .map((p) => `${p.rustName},`)
+            .join(" ");
+          requestExpr = `${requestName} { ${pathAssignments} ..query }`;
+        } else {
+          requestExpr = "query";
+        }
+      } else if (hasBody) {
+        if (hasPathParams) {
+          const pathAssignments = pathParams
+            .map((p) => `${p.rustName},`)
+            .join(" ");
+          requestExpr = `${requestName} { ${pathAssignments} body }`;
+        } else {
+          requestExpr = `${requestName} { body }`;
+        }
+      } else {
+        requestExpr = `${requestName} {}`;
+      }
+
+      // Server method call
+      const serverCall = isProtected
+        ? `service.${traitFnName}(claims, ${requestExpr}).await`
+        : `service.${traitFnName}(${requestExpr}).await`;
+
+      // All handlers use <S> generics, Claims is now an associated type
+      let handlerCode = `pub async fn ${handlerFnName}_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+${extractorLines.join("\n")}
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = ${serverCall};
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}`;
+
+      handlers.push(handlerCode);
+
+      let routePath = `"${opInfo.path}"`;
+      let routeStmt = "";
+      if (isProtected) {
+        routeStmt = `.route(${routePath}, ${method}(${handlerFnName}_handler::<S>))`;
+        protectedRoutes.push(routeStmt);
+      } else {
+        routeStmt = `.route(${routePath}, ${method}(${handlerFnName}_handler::<S>))`;
+        publicRoutes.push(routeStmt);
+      }
+    }
+  }
+
+  const methodImports = Array.from(usedMethods).sort().join(", ");
+
+  const routerBody = buildRouterBody(publicRoutes, protectedRoutes);
+
+  const parts: string[] = [];
+  parts.push(`use axum::response::IntoResponse;
+use axum::routing::{${methodImports}};
+use axum::Router;
+
+`);
+  parts.push(handlers.join("\n\n"));
+  parts.push(`
+pub fn create_router<S, M>(service: S, middleware: M) -> Router
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+    M: FnOnce(Router<S>) -> Router<S> + Clone + Send + Sync + 'static,
+{
+${routerBody}
+}`);
+
+  return parts.join("\n");
+}
+
+function hasOnlyPathParams(
+  hasPath: boolean,
+  hasQuery: boolean,
+  hasBody: boolean,
+): boolean {
+  return hasPath && !hasQuery && !hasBody;
+}
+
+function buildRouterBody(
+  publicRoutes: string[],
+  protectedRoutes: string[],
+): string {
+  const lines: string[] = [];
+  lines.push("    let mut router = Router::new();");
+  if (publicRoutes.length > 0) {
+    lines.push("    let public = Router::new()");
+    for (const r of publicRoutes) {
+      lines.push(`        ${r.trim()}`);
+    }
+    lines.push("        ;");
+    lines.push("    router = router.merge(public);");
+  }
+  if (protectedRoutes.length > 0) {
+    lines.push("    let protected = Router::new()");
+    for (const r of protectedRoutes) {
+      lines.push(`        ${r.trim()}`);
+    }
+    lines.push("        ;");
+    lines.push("    router = router.merge(middleware(protected));");
+  }
+  lines.push("    router.with_state(service)");
+  return lines.join("\n");
+}
+
 const scalarToRust: Record<string, string> = {
   string: "String",
   int8: "i8",
@@ -403,10 +1115,8 @@ function emitModel(
     parts.push('#[error("{code}: {message}")]');
   }
 
-  parts.push(`pub struct ${name}`);
-
   if (allProps.size > 0) {
-    parts.push(" {");
+    const fields: string[] = [];
     for (const [propName, prop] of allProps) {
       const doc = getDoc(program, prop);
       const { type: rustType } = getRustTypeForProperty(
@@ -420,20 +1130,23 @@ function emitModel(
         propName !== fieldName ? `#[serde(rename = "${propName}")]` : "";
 
       if (doc) {
-        parts.push(`\n  ${formatDoc(doc)}`);
+        fields.push(`  ${formatDoc(doc)}`);
       }
       if (serdeRename) {
-        parts.push(`  ${serdeRename}`);
+        fields.push(`  ${serdeRename}`);
       }
       if (optional) {
-        parts.push(`  #[serde(skip_serializing_if = "Option::is_none")]`);
+        fields.push(`  #[serde(skip_serializing_if = "Option::is_none")]`);
       }
-      parts.push(
+      fields.push(
         `  pub ${fieldName}: ${optional ? `Option<${rustType}>` : rustType},`,
       );
     }
-    parts.push("}");
+    parts.push(`pub struct ${name} {
+${fields.join("\n")}
+}`);
   } else {
+    parts.push(`pub struct ${name}`);
     parts.push("(());");
   }
 
@@ -676,10 +1389,47 @@ export async function $onEmit(
     content.push("");
   }
 
+  const namespaceGroups = getAllOperations(context.program);
+
   const outputContent = content.join("\n");
 
   await emitFile(context.program, {
     path: resolvePath(context.emitterOutputDir, "types.rs"),
     content: outputContent,
   });
+
+  if (namespaceGroups.length > 0) {
+    const serverTrait = generateServerTrait(
+      context.program,
+      namespaceGroups,
+      anonymousEnums,
+    );
+    const requestStructs = generateRequestStructs(
+      context.program,
+      namespaceGroups,
+      anonymousEnums,
+    );
+    const responseEnums = generateResponseEnums(
+      context.program,
+      namespaceGroups,
+      anonymousEnums,
+    );
+    const router = generateRouter(
+      context.program,
+      namespaceGroups,
+      anonymousEnums,
+    );
+
+    const serverContent = [
+      serverTrait,
+      requestStructs,
+      responseEnums,
+      router,
+    ].join("\n");
+
+    await emitFile(context.program, {
+      path: resolvePath(context.emitterOutputDir, "server.rs"),
+      content: serverContent,
+    });
+  }
 }