typespec-rust-emitter 0.2.0 → 0.4.0

package/src/emitter.ts

@@ -33,34 +33,45 @@ interface RustDeriveInfo {
   derives: string[];
 }
 
+interface RustAttrInfo {
+  attrs: string[];
+}
+
 const rustDeriveKey = Symbol("rustDerive");
+const rustAttrKey = Symbol("rustAttr");
 
 export function $rustDerive(
   context: DecoratorContext,
   target: Type,
   derive: string,
 ) {
-  if (target.kind !== "Model") {
+  if (target.kind !== "Model" && target.kind !== "Enum") {
     context.program.reportDiagnostic({
       code: "rust-derive-invalid-target",
-      message: `@rustDerive can only be applied to models`,
+      message: `@rustDerive can only be applied to models and enums`,
       severity: "error",
       target: context.decoratorTarget,
     });
     return;
   }
 
-  const model = target as Model;
-  const ns = model.namespace ? getNamespaceFullName(model.namespace) : "";
+  const ns =
+    target.kind === "Model"
+      ? target.namespace
+        ? getNamespaceFullName(target.namespace)
+        : ""
+      : target.namespace
+        ? getNamespaceFullName(target.namespace)
+        : "";
 
   if (!ns.startsWith("TypeSpec")) {
-    const info = (model as any)[rustDeriveKey] as RustDeriveInfo | undefined;
+    const info = (target as any)[rustDeriveKey] as RustDeriveInfo | undefined;
     if (info) {
       if (!info.derives.includes(derive)) {
         info.derives.push(derive);
       }
     } else {
-      (model as any)[rustDeriveKey] = { derives: [derive] };
+      (target as any)[rustDeriveKey] = { derives: [derive] };
     }
   }
 }
@@ -75,6 +86,52 @@ export function $rustDerives(
   }
 }
 
+export function $rustAttr(
+  context: DecoratorContext,
+  target: Type,
+  attr: string,
+) {
+  if (target.kind !== "Model" && target.kind !== "Enum") {
+    context.program.reportDiagnostic({
+      code: "rust-attr-invalid-target",
+      message: `@rustAttr can only be applied to models and enums`,
+      severity: "error",
+      target: context.decoratorTarget,
+    });
+    return;
+  }
+
+  const ns =
+    target.kind === "Model"
+      ? target.namespace
+        ? getNamespaceFullName(target.namespace)
+        : ""
+      : target.namespace
+        ? getNamespaceFullName(target.namespace)
+        : "";
+
+  if (!ns.startsWith("TypeSpec")) {
+    const info = (target as any)[rustAttrKey] as RustAttrInfo | undefined;
+    if (info) {
+      if (!info.attrs.includes(attr)) {
+        info.attrs.push(attr);
+      }
+    } else {
+      (target as any)[rustAttrKey] = { attrs: [attr] };
+    }
+  }
+}
+
+export function $rustAttrs(
+  context: DecoratorContext,
+  target: Type,
+  ...attrs: string[]
+) {
+  for (const attr of attrs) {
+    $rustAttr(context, target, attr);
+  }
+}
+
 type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
 
 interface OperationInfo {
@@ -188,22 +245,45 @@ function getOperationParameters(
 
   for (const [propName, prop] of model.properties) {
     const decorators = (prop as any).decorators;
+
+    // Skip body parameters - they are handled separately
+    let isBody = false;
+    if (decorators) {
+      for (const key of Object.keys(decorators)) {
+        const decorator = decorators[key];
+        const name = getDecoratorName(decorator);
+        if (name === "body" || name === "bodyRoot") {
+          isBody = true;
+          break;
+        }
+      }
+    }
+    if (isBody) continue;
+
     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;
+      for (const key of Object.keys(decorators)) {
+        const decorator = decorators[key];
+        const name = getDecoratorName(decorator);
+        if (name === "path") {
+          location = "path";
+          break;
+        } else if (name === "query") {
+          location = "query";
+          break;
+        } else if (name === "header") {
+          location = "header";
+          const headerVal = getDecoratorArgValue(decorator, 0);
+          if (headerVal) {
+            rustName = toRustIdent(headerVal);
+          }
+          break;
+        } else if (name === "cookie") {
+          location = "cookie";
+          break;
         }
-      } else if (decorators["$cookie"]) {
-        location = "cookie";
       }
     }
 
@@ -229,8 +309,14 @@ function getOperationParameters(
 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;
+    if (!decorators) continue;
+
+    for (const key of Object.keys(decorators)) {
+      const decorator = decorators[key];
+      const name = getDecoratorName(decorator);
+      if (name === "body" || name === "bodyRoot") {
+        return prop;
+      }
     }
   }
   return undefined;
@@ -434,6 +520,8 @@ function generateServerTrait(
   parts.push(`use super::types::*;
 use async_trait::async_trait;
 use axum::{http::StatusCode, Json};
+use axum::extract::Path;
+use axum::Extension;
 use eyre::Result;
 
 #[async_trait]
@@ -455,75 +543,58 @@ pub trait Server: Send + Sync {
         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[] = [];
+      // Build parameter list for the trait method
+      const paramParts: 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},`);
+      // Add path parameters
+      for (const param of opInfo.parameters) {
+        if (param.location === "path") {
+          paramParts.push(`${param.rustName}: ${param.rustType}`);
+        }
       }
 
+      // Add body parameter
       if (opInfo.body) {
         const bodyType = getRustTypeForProperty(
           opInfo.body.type,
           program,
           anonymousEnums,
         );
-        fields.push(`  #[serde(rename = "body")]`);
-        fields.push(`  pub body: ${bodyType.type},`);
+        paramParts.push(`body: ${bodyType.type}`);
       }
 
-      parts.push(`#[derive(Debug, Clone, serde::Deserialize)]
-pub struct ${requestName} {
-${fields.join("\n")}
-}
-`);
+      const paramsStr = paramParts.join(", ");
+
+      if (isProtected) {
+        if (paramsStr) {
+          parts.push(
+            `    async fn ${fnName}(&self, claims: Self::Claims, ${paramsStr}) -> Result<${responseName}>;`,
+          );
+        } else {
+          parts.push(
+            `    async fn ${fnName}(&self, claims: Self::Claims) -> Result<${responseName}>;`,
+          );
+        }
+      } else {
+        if (paramsStr) {
+          parts.push(
+            `    async fn ${fnName}(&self, ${paramsStr}) -> Result<${responseName}>;`,
+          );
+        } else {
+          parts.push(
+            `    async fn ${fnName}(&self) -> Result<${responseName}>;`,
+          );
+        }
+      }
     }
   }
 
+  parts.push("}");
+
   return parts.join("\n");
 }
 
@@ -615,83 +686,57 @@ function generateRouter(
 
       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
+      // Build extractor lines and server method call arguments
+      // IMPORTANT: axum requires specific extractor order:
+      // State -> Extension -> Path -> Query -> Json -> Body
       const extractorLines: string[] = [];
-      let requestExpr = "";
+      const serverArgs: string[] = [];
 
+      // State is always first (added in handler template)
+
+      // Extension (claims) comes after State
+      if (isProtected) {
+        extractorLines.push(`    Extension(claims): Extension<S::Claims>,`);
+        serverArgs.push(`claims`);
+      }
+
+      // Path params come after Extension
       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}>,`,
-          );
+          extractorLines.push(`    Path(${pathFields}): Path<${pathTypes}>,`);
         } else {
           extractorLines.push(
-            `    axum::extract::Path((${pathFields})): axum::extract::Path<(${pathTypes})>,`,
+            `    Path((${pathFields})): Path<(${pathTypes})>,`,
           );
         }
+        // Add path params to server method args
+        for (const param of pathParams) {
+          serverArgs.push(param.rustName);
+        }
       }
 
-      if (hasQueryParams) {
-        extractorLines.push(
-          `    axum::extract::Query(query): axum::extract::Query<${requestName}>,`,
-        );
-      } else if (hasBody) {
-        extractorLines.push(
-          `    axum::Json(body): axum::Json<${requestName}Body>,`,
+      // Json body comes last
+      if (hasBody && opInfo.body) {
+        const bodyType = getRustTypeForProperty(
+          opInfo.body.type,
+          program,
+          anonymousEnums,
         );
+        extractorLines.push(`    Json(payload): Json<${bodyType.type}>,`);
+        serverArgs.push(`payload`);
       }
 
-      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`;
+      // Build server method call
+      const serverArgsStr = serverArgs.join(", ");
+      const serverCall = `service.${traitFnName}(${serverArgsStr}).await`;
 
       // All handlers use <S> generics, Claims is now an associated type
       let handlerCode = `pub async fn ${handlerFnName}_handler<S>(
@@ -1115,6 +1160,13 @@ function emitModel(
     parts.push('#[error("{code}: {message}")]');
   }
 
+  const customAttrs = (model as any)[rustAttrKey] as RustAttrInfo | undefined;
+  if (customAttrs) {
+    for (const attr of customAttrs.attrs) {
+      parts.push(`#[${attr}]`);
+    }
+  }
+
   if (allProps.size > 0) {
     const fields: string[] = [];
     for (const [propName, prop] of allProps) {
@@ -1181,10 +1233,41 @@ function emitEnum(enumType: Enum): string {
     (m) => m.value === undefined || typeof m.value === "string",
   );
 
+  const baseDerives = [
+    "Debug",
+    "Clone",
+    "Copy",
+    "PartialEq",
+    "Eq",
+    "Hash",
+    "serde::Serialize",
+    "serde::Deserialize",
+  ];
+
+  const customDerives = (enumType as any)[rustDeriveKey] as
+    | RustDeriveInfo
+    | undefined;
+  const allDerives = [...baseDerives];
+  if (customDerives) {
+    allDerives.push(...customDerives.derives);
+  }
+
+  const customAttrs = (enumType as any)[rustAttrKey] as
+    | RustAttrInfo
+    | undefined;
+  const attrLines: string[] = [];
+  if (customAttrs) {
+    for (const attr of customAttrs.attrs) {
+      attrLines.push(`#[${attr}]`);
+    }
+  }
+
   if (isString) {
-    parts.push(
-      `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]\npub enum ${name} {`,
-    );
+    parts.push(`#[derive(${allDerives.join(", ")})]`);
+    if (attrLines.length > 0) {
+      parts.push(...attrLines);
+    }
+    parts.push(`pub enum ${name} {`);
     for (const member of members) {
       const variantName = toRustVariantName(member.name);
       const serdeValue = member.value ?? member.name;
@@ -1192,9 +1275,11 @@ function emitEnum(enumType: Enum): string {
       parts.push(`  ${variantName},`);
     }
   } else {
-    parts.push(
-      `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]\npub enum ${name} {`,
-    );
+    parts.push(`#[derive(${allDerives.join(", ")})]`);
+    if (attrLines.length > 0) {
+      parts.push(...attrLines);
+    }
+    parts.push(`pub enum ${name} {`);
     for (const member of members) {
       const variantName = toRustVariantName(member.name);
       const enumValue = member.value ?? 0;
@@ -1404,11 +1489,6 @@ export async function $onEmit(
       namespaceGroups,
       anonymousEnums,
     );
-    const requestStructs = generateRequestStructs(
-      context.program,
-      namespaceGroups,
-      anonymousEnums,
-    );
     const responseEnums = generateResponseEnums(
       context.program,
       namespaceGroups,
@@ -1420,12 +1500,7 @@ export async function $onEmit(
       anonymousEnums,
     );
 
-    const serverContent = [
-      serverTrait,
-      requestStructs,
-      responseEnums,
-      router,
-    ].join("\n");
+    const serverContent = [serverTrait, responseEnums, router].join("\n");
 
     await emitFile(context.program, {
       path: resolvePath(context.emitterOutputDir, "server.rs"),

package/src/index.ts

@@ -1,3 +1,3 @@
 export { $onEmit } from "./emitter.js";
-export { $rustDerive, $rustDerives } from "./emitter.js";
+export { $rustDerive, $rustDerives, $rustAttr, $rustAttrs } from "./emitter.js";
 export { $lib } from "./lib.js";

package/src/lib.tsp

@@ -2,5 +2,7 @@ import "../dist/src/emitter.js";
 
 using TypeSpec.Reflection;
 
-extern dec rustDerive(target: Model, derive: valueof string);
-extern dec rustDerives(target: Model, ...derives: valueof string[]);
+extern dec rustDerive(target: Model | Enum, derive: valueof string);
+extern dec rustDerives(target: Model | Enum, ...derives: valueof string[]);
+extern dec rustAttr(target: Model | Enum, attr: valueof string);
+extern dec rustAttrs(target: Model | Enum, ...attrs: valueof string[]);

package/test/hello.test.ts

@@ -165,4 +165,104 @@ describe("Rust emitter", () => {
       true,
     );
   });
+
+  it("emits custom rustDerive on enum", async () => {
+    const results = await emit(`
+      import "typespec-rust-emitter";
+
+      @rustDerive("strum::Display")
+      enum Status {
+        active,
+        inactive,
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(
+      output.includes(
+        "#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize, strum::Display)]",
+      ),
+      true,
+    );
+  });
+
+  it("emits multiple rustDerive macros on enum via $rustDerives", async () => {
+    const results = await emit(`
+      import "typespec-rust-emitter";
+
+      @rustDerives("strum::Display", "strum::EnumString")
+      enum Priority {
+        low,
+        high,
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(
+      output.includes(
+        "#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize, strum::Display, strum::EnumString)]",
+      ),
+      true,
+    );
+  });
+
+  it("emits custom rustAttr on model", async () => {
+    const results = await emit(`
+      import "typespec-rust-emitter";
+
+      @rustAttr("sqlx(type_name = \\"user\\")")
+      model User {
+        name: string;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes('#[sqlx(type_name = "user")]'), true);
+  });
+
+  it("emits multiple rustAttrs on model via $rustAttrs", async () => {
+    const results = await emit(`
+      import "typespec-rust-emitter";
+
+      @rustAttrs("sqlx(type_name = \\"user\\")", "cfg_attr(feature = \\"test\\", derive(Debug))")
+      model Person {
+        name: string;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes('#[sqlx(type_name = "user")]'), true);
+    strictEqual(
+      output.includes('#[cfg_attr(feature = "test", derive(Debug))]'),
+      true,
+    );
+  });
+
+  it("emits custom rustAttr on enum", async () => {
+    const results = await emit(`
+      import "typespec-rust-emitter";
+
+      @rustAttr("sqlx(type_name = \\"study_status\\")")
+      enum Status {
+        active,
+        inactive,
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes('#[sqlx(type_name = "study_status")]'), true);
+  });
+
+  it("emits multiple rustAttrs on enum via $rustAttrs", async () => {
+    const results = await emit(`
+      import "typespec-rust-emitter";
+
+      @rustAttrs("sqlx(type_name = \\"priority\\")", "cfg_attr(feature = \\"test\\", derive(Debug))")
+      enum Priority {
+        low,
+        high,
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes('#[sqlx(type_name = "priority")]'), true);
+    strictEqual(
+      output.includes('#[cfg_attr(feature = "test", derive(Debug))]'),
+      true,
+    );
+  });
 });