typespec-rust-emitter 0.8.0 → 0.10.0

package/src/emitter.ts

@@ -8,7 +8,6 @@ import {
   isRecordModelType,
   getFormat,
   getPattern,
-  isErrorModel,
   Type,
   Model,
   ModelProperty,
@@ -39,6 +38,11 @@ interface RustAttrInfo {
 
 const rustDeriveKey = Symbol("rustDerive");
 const rustAttrKey = Symbol("rustAttr");
+const rustImplKey = Symbol("rustImpl");
+
+interface RustImplInfo {
+  impl: string;
+}
 
 export function $rustDerive(
   context: DecoratorContext,
@@ -136,6 +140,29 @@ export function $rustAttrs(
   }
 }
 
+export function $rustImpl(
+  context: DecoratorContext,
+  target: Type,
+  impl: string,
+) {
+  if (target.kind !== "Model") {
+    context.program.reportDiagnostic({
+      code: "rust-impl-invalid-target",
+      message: `@rustImpl can only be applied to models`,
+      severity: "error",
+      target: context.decoratorTarget,
+    });
+    return;
+  }
+
+  const ns = target.namespace ? getNamespaceFullName(target.namespace) : "";
+
+  if (!ns.startsWith("TypeSpec")) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (target as any)[rustImplKey] = { impl: impl };
+  }
+}
+
 type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
 
 interface OperationInfo {
@@ -558,13 +585,6 @@ function getHttpStatusCode(statusCode: number): string {
   return statusCodes[statusCode] || `StatusCode::from_u16(${statusCode})`;
 }
 
-function getHttpStatusCodeForError(errorName: string): string {
-  if (errorName.endsWith("NotFoundError")) return "NOT_FOUND";
-  if (errorName.endsWith("ValidationError")) return "BAD_REQUEST";
-  if (errorName.endsWith("ConflictError")) return "CONFLICT";
-  return "INTERNAL_SERVER_ERROR";
-}
-
 function generateServerTrait(
   program: Program,
   namespaceGroups: { namespace: Namespace; operations: Operation[] }[],
@@ -1154,24 +1174,21 @@ function emitStringLiteralUnion(union: Union): string {
   const variants = Array.from(union.variants.values());
 
   parts.push(
-    `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]\npub enum ${name} {`,
+    `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\npub enum ${name} {`,
   );
 
-  for (const variant of variants) {
-    const literalType = variant.type as StringLiteral;
+  for (let i = 0; i < variants.length; i++) {
+    const literalType = variants[i].type as StringLiteral;
     const variantName = toRustVariantName(literalType.value);
     const serdeValue = literalType.value;
+    if (i === 0) {
+      parts.push(`  #[default]`);
+    }
     parts.push(`  #[serde(rename = "${serdeValue}")]`);
     parts.push(`  ${variantName},`);
   }
 
   parts.push("}");
-  const defaultVariant = toRustVariantName(
-    variants[0]?.type ? (variants[0].type as StringLiteral).value : "",
-  );
-  parts.push(
-    `\n\nimpl Default for ${name} {\n  fn default() -> Self {\n    ${name}::${defaultVariant}\n  }\n}`,
-  );
   return parts.join("\n");
 }
 
@@ -1183,7 +1200,6 @@ function emitModel(
   const parts: string[] = [];
   const name = toPascalCase(model.name);
   const allProps = getAllProperties(model, program);
-  const isError = isErrorModel(program, model);
 
   const deriveAttrs = [
     "Debug",
@@ -1200,16 +1216,8 @@ function emitModel(
     deriveAttrs.push(...customDerives.derives);
   }
 
-  if (isError) {
-    deriveAttrs.push("thiserror::Error");
-  }
-
   parts.push(`#[derive(${deriveAttrs.join(", ")})]`);
 
-  if (isError && allProps.size > 0) {
-    parts.push('#[error("{code}: {message}")]');
-  }
-
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const customAttrs = (model as any)[rustAttrKey] as RustAttrInfo | undefined;
   if (customAttrs) {
@@ -1253,14 +1261,11 @@ ${fields.join("\n")}
     parts.push("(());");
   }
 
-  if (isError && allProps.size > 0) {
-    const statusCode = getHttpStatusCodeForError(name);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const customImpl = (model as any)[rustImplKey] as RustImplInfo | undefined;
+  if (customImpl) {
     parts.push(`
-impl IntoResponse for ${name} {
-    fn into_response(self) -> axum::response::Response {
-        (StatusCode::${statusCode}, Json(self)).into_response()
-    }
-}`);
+${customImpl.impl}`);
   }
 
   return parts.join("\n");
@@ -1301,6 +1306,7 @@ function emitEnum(enumType: Enum): string {
     "PartialEq",
     "Eq",
     "Hash",
+    "Default",
     "serde::Serialize",
     "serde::Deserialize",
   ];
@@ -1331,9 +1337,12 @@ function emitEnum(enumType: Enum): string {
       parts.push(...attrLines);
     }
     parts.push(`pub enum ${name} {`);
-    for (const member of members) {
-      const variantName = toRustVariantName(member.name);
-      const serdeValue = member.value ?? member.name;
+    for (let i = 0; i < members.length; i++) {
+      const variantName = toRustVariantName(members[i].name);
+      const serdeValue = members[i].value ?? members[i].name;
+      if (i === 0) {
+        parts.push(`  #[default]`);
+      }
       parts.push(`  #[serde(rename = "${serdeValue}")]`);
       parts.push(`  ${variantName},`);
     }
@@ -1343,17 +1352,16 @@ function emitEnum(enumType: Enum): string {
       parts.push(...attrLines);
     }
     parts.push(`pub enum ${name} {`);
-    for (const member of members) {
-      const variantName = toRustVariantName(member.name);
-      const enumValue = member.value ?? 0;
+    for (let i = 0; i < members.length; i++) {
+      const variantName = toRustVariantName(members[i].name);
+      const enumValue = members[i].value ?? 0;
+      if (i === 0) {
+        parts.push(`  #[default]`);
+      }
       parts.push(`  ${variantName} = ${enumValue},`);
     }
   }
   parts.push("}");
-  const defaultVariant = toRustVariantName(members[0]?.name ?? "");
-  parts.push(
-    `\n\nimpl Default for ${name} {\n  fn default() -> Self {\n    ${name}::${defaultVariant}\n  }\n}`,
-  );
   return parts.join("\n");
 }
 
@@ -1408,12 +1416,9 @@ function emitScalar(
     impls.push(
       `\nimpl TryFrom<String> for ${structName} {\n  type Error = String;\n\n  fn try_from(value: String) -> Result<Self, Self::Error> {\n    let re = regex::Regex::new(r"${pattern}").unwrap();\n    if re.is_match(&value) { Ok(Self(value)) } else { Err(format!("Invalid value: {}", value)) }\n  }\n}`,
     );
-    impls.push(
-      `\nimpl Default for ${structName} {\n  fn default() -> Self {\n    Self(String::new())\n  }\n}`,
-    );
 
     return {
-      typeDef: `#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]\npub struct ${structName}(pub ${rustType});`,
+      typeDef: `#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\npub struct ${structName}(pub ${rustType});`,
       impls,
     };
   }
@@ -1497,18 +1502,18 @@ export async function $onEmit(
   for (const [enumName, anonEnum] of anonymousEnums) {
     const parts: string[] = [];
     parts.push(
-      `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]\npub enum ${enumName} {`,
+      `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\npub enum ${enumName} {`,
     );
-    for (const literal of anonEnum.variants) {
+    for (let i = 0; i < anonEnum.variants.length; i++) {
+      const literal = anonEnum.variants[i];
       const variantName = toRustVariantName(literal.value);
+      if (i === 0) {
+        parts.push(`  #[default]`);
+      }
       parts.push(`  #[serde(rename = "${literal.value}")]`);
       parts.push(`  ${variantName},`);
     }
     parts.push("}");
-    const defaultVariant = toRustVariantName(anonEnum.variants[0]?.value ?? "");
-    parts.push(
-      `\n\nimpl Default for ${enumName} {\n  fn default() -> Self {\n    ${enumName}::${defaultVariant}\n  }\n}`,
-    );
     content.push(parts.join("\n"));
     content.push("");
   }
@@ -1541,6 +1546,7 @@ export async function $onEmit(
 
   const outputContent =
     "#![allow(unused)]\n\n" +
+    "use std::str::FromStr;\n" +
     "use axum::http::StatusCode;\n" +
     "use axum::response::IntoResponse;\n" +
     "use axum::Json;\n\n" +

package/src/index.ts

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

package/src/lib.tsp

@@ -6,3 +6,4 @@ 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[]);
+extern dec rustImpl(target: Model, impl: valueof string);

package/test/hello.test.ts

@@ -179,7 +179,7 @@ describe("Rust emitter", () => {
     const output = results["types.rs"];
     strictEqual(
       output.includes(
-        "#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize, strum::Display)]",
+        "#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize, strum::Display)]",
       ),
       true,
     );
@@ -198,7 +198,7 @@ describe("Rust emitter", () => {
     const output = results["types.rs"];
     strictEqual(
       output.includes(
-        "#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize, strum::Display, strum::EnumString)]",
+        "#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize, strum::Display, strum::EnumString)]",
       ),
       true,
     );
@@ -265,4 +265,67 @@ describe("Rust emitter", () => {
       true,
     );
   });
+
+  it("does not add thiserror::Error by default on @error model", async () => {
+    const results = await emit(`
+      import "typespec-rust-emitter";
+
+      @error
+      model ApiError {
+        code: int32;
+        message: string;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes("thiserror::Error"), false);
+    strictEqual(output.includes('#[error("{code}: {message}")]'), false);
+  });
+
+  it("allows user to add thiserror::Error and error attribute manually", async () => {
+    const results = await emit(`
+      import "typespec-rust-emitter";
+
+      @rustDerive("thiserror::Error")
+      @rustAttr("error(\\"{code}: {message}\\")")
+      model ApiError {
+        code: int32;
+        message: string;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes("thiserror::Error"), true);
+    strictEqual(output.includes('#[error("{code}: {message}")]'), true);
+  });
+
+  it("allows user to add custom impl blocks", async () => {
+    const results = await emit(`
+      import "typespec-rust-emitter";
+
+      @rustImpl("impl IntoResponse for ApiError { fn into_response(self) -> axum::response::Response { self.message.into_response() } }")
+      model ApiError {
+        @doc("Human-readable message.")
+        message: string;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes("impl IntoResponse for ApiError"), true);
+    strictEqual(
+      output.includes("fn into_response(self) -> axum::response::Response"),
+      true,
+    );
+    strictEqual(output.includes("self.message.into_response()"), true);
+  });
+
+  it("uses default IntoResponse when no custom impl provided", async () => {
+    const results = await emit(`
+      import "typespec-rust-emitter";
+
+      model ApiError {
+        code: int32;
+        message: string;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes("impl IntoResponse for ApiError"), false);
+  });
 });