typespec-rust-emitter 0.8.0 → 0.10.0

package/.env

@@ -0,0 +1 @@
+NPM_TOKEN=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

package/AGENTS.md

@@ -1,167 +1,58 @@
-# TypeSpec Rust Emitter - Agent Guidelines
+# TypeSpec Rust Emitter
 
-## Overview
+TypeSpec emitter generating idiomatic Rust code (structs, enums, server traits).
 
-TypeSpec emitter that generates idiomatic Rust code (structs, enums, server traits) from TypeSpec specifications.
-
-## Build, Lint, and Test Commands
-
-### Standard Commands
+## Commands
 
 ```bash
-# Build TypeScript
-npm run build           # or: just build
-
-# Run tests
-npm test                # or: just test
-node --test 'dist/test/**/*.test.js'
-
-# Run a single test file
-node --test 'dist/test/hello.test.js'
+# Build -> test (lint runs automatically)
+npm run build && npm test
 
-# Run a specific test
-node --test 'dist/test/hello.test.js' --test-name-pattern="emits model"
+# Run tests only
+npm test
 
-# Lint
-npm run lint            # Check linting
-npm run lint:fix        # Auto-fix linting issues
+# Single test: node --test 'dist/test/hello.test.js' --test-name-pattern="emits model"
 
-# Format code
-npm run format          # Format all files
-npm run format:check    # Check formatting without changes
+# Lint & format (run after every change)
+npm run lint
+npm run format
 
 # Compile TypeSpec to Rust
-just compile            # Runs: cd example && tsp compile .
-
-# Verify generated Rust compiles
-just check-rust         # Runs: cd example/output-rust && cargo check
-```
-
-### Full Development Cycle
-
-After every change, run this sequence:
-
-```bash
-just build && npm test && just compile && just check-rust
-```
-
-## Project Structure
-
-| Path                                 | Purpose                                                  |
-| ------------------------------------ | -------------------------------------------------------- |
-| `src/emitter.ts`                     | Main emitter logic (~1500 lines) - TypeSpec→Rust codegen |
-| `src/lib.tsp`                        | Decorator declarations (`@rustDerive`, `@rustDerives`)   |
-| `src/lib.ts`                         | Decorator implementations                                |
-| `src/index.ts`                       | Public API exports                                       |
-| `src/testing/index.ts`               | Test utilities                                           |
-| `test/hello.test.ts`                 | Unit tests using `emit()` helper                         |
-| `test/test-host.ts`                  | Test host setup                                          |
-| `example/lib/`                       | Demo TypeSpec models & operations                        |
-| `example/output-rust/src/generated/` | Generated Rust output                                    |
-
-## Code Style
-
-### TypeScript
-
-- **Strict mode enabled** - No implicit `any`
-- **No `any` types** - Use `unknown` or proper generics instead
-- **Explicit return types** on public functions
-- **Interfaces over type aliases** for object shapes
+cd example && tsp compile .
 
-### Imports
-
-- Named imports from `@typespec/compiler` first, then external packages
-- Group imports: 1) `@typespec/*`, 2) external, 3) internal
-- Use `import type { X }` for type-only imports when appropriate
-
-### Formatting (Prettier)
-
-Configuration in `prettierrc.yaml`:
-
-- `printWidth: 120`
-- `trailingComma: "all"`
-- `arrowParens: always`
-- `endOfLine: lf`
-
-Use `npm run format` before committing.
-
-### Naming Conventions
-
-| Element                     | Convention | Example              |
-| --------------------------- | ---------- | -------------------- |
-| TypeScript functions        | camelCase  | `$rustDerive`        |
-| TypeScript types/interfaces | PascalCase | `RustEmitterOptions` |
-| Rust types                  | PascalCase | `pub struct User`    |
-| Rust functions/methods      | snake_case | `get_user_by_id`     |
-| Internal symbols            | camelCase  | `rustDeriveKey`      |
-
-### Type Mappings (TypeSpec → Rust)
-
-| TypeSpec               | Rust                    |
-| ---------------------- | ----------------------- |
-| `string`               | `String`                |
-| `int32/64`             | `i32/i64`               |
-| `float32/64`           | `f32/f64`               |
-| `boolean`              | `bool`                  |
-| `T \| null`            | `Option<T>`             |
-| `T[]`                  | `Vec<T>`                |
-| `Record<T>`            | `HashMap<String, T>`    |
-| `@format("uuid")`      | `uuid::Uuid`            |
-| `@format("date-time")` | `chrono::DateTime<Utc>` |
-
-## Error Handling
-
-- Use `context.program.reportDiagnostic()` for errors and warnings
-- Diagnostic codes should use kebab-case: `code: "rust-derive-invalid-target"`
-- Always specify `severity: "error"` or `"warning"`
-- Include `target: context.decoratorTarget` for location info
-
-## Testing Pattern
-
-```typescript
-import { emit } from "./test-host.js";
-
-const results = await emit(`model User { name: string; }`);
-const output = results["types.rs"];
-strictEqual(output.includes("pub struct User"), true);
+# Verify Rust compiles
+cd example/output-rust && cargo check
 ```
 
-## Server Trait Generation Rules
-
-1. Generates `Server<Claims>` trait with async methods per operation
-2. Handler functions: `pub async fn {op}_handler<S, Claims>(...)`
-3. All handlers use `<S, Claims>` generics (even public routes)
-4. Protected routes (`@useAuth`) receive `claims: Claims` parameter
-5. Router splits public/protected routes, merges at end
-6. Public routes include `Claims: Send + Sync + Clone + 'static` bound
-
-## Architecture
+## Project Layout
 
-1. `navigateProgram()` walks TypeSpec AST
-2. Collects models, enums, operations
-3. Processes decorators
-4. Generates Rust code via string templates
-5. Emits to `example/output-rust/src/generated/`
+| Path | Purpose |
+|------|--------|
+| `src/emitter.ts` | Main codegen (~1600 lines) |
+| `src/lib.tsp` | Decorator declarations |
+| `src/index.ts` | Exports |
+| `test/hello.test.ts` | Unit tests |
+| `example/lib/` | Demo TypeSpec specs |
+| `example/output-rust/` | Generated Rust |
 
-## Linting
+## Decorators
 
-ESLint config (`eslint.config.js`):
+All decorators go in `src/lib.tsp` (declaration) + `src/emitter.ts` (implementation):
+- `@rustDerive` / `@rustDerives` - derive macros
+- `@rustAttr` / `@rustAttrs` - attribute macros
+- `@rustImpl` - custom impl blocks
 
-- Uses `typescript-eslint` recommended rules
-- Ignores `dist/**` and `.temp/**`
-- Unused variables: warn with `_` prefix exception
+## Style
 
-## Commit Message Style
+- Strict TypeScript: no implicit `any`, explicit return types
+- Prettier: `printWidth: 120`, `trailingComma: "all"` (see `prettierrc.yaml`)
+- Import order: `@typespec/*`, external, internal
 
-- Use clear, descriptive titles
-- Focus on "why" rather than "what"
-- Keep concise (1-2 sentences)
-- Example: "Fix handler generics for public routes without auth"
+## Release (let user handle)
 
-## Checklist Before PR
+When releasing a new version:
+1. Bump `version` in `package.json`
+2. Update `CHANGELOG.md` (include issue refs)
+3. Run `just publish` (requires `NPM_TOKEN` in `.env` or env var)
 
-- [ ] Run full cycle: `just build && npm test && just compile && just check-rust`
-- [ ] Add tests for new features
-- [ ] Run `npm run lint` and `npm run format`
-- [ ] Generated Rust must compile with `cargo check`
-- [ ] No TypeScript errors
+Do not publish yourself—inform user when ready for release.

package/CHANGELOG.md

@@ -5,6 +5,98 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.10.0] - 2026-04-18
+
+### Added
+
+- **@rustImpl decorator for custom impl blocks**: New decorator allows adding arbitrary `impl` blocks to models
+  - Enables custom implementations like `IntoResponse`, trait implementations, or any custom methods
+  - Example: `@rustImpl("impl IntoResponse for ApiError { ... }")`
+
+### Changed
+
+- **Breaking**: Removed automatic `thiserror::Error` derive from `@error` models
+  - Users must now add manually via `@rustDerive("thiserror::Error")` and `@rustAttr("error(\"{code}: {message}\")")`
+  - Provides full control over error behavior
+- **Breaking**: Removed automatic `IntoResponse` implementation for error models
+  - Users can add custom impl via `@rustImpl` decorator
+  - Example:
+    ```typespec
+    @rustDerive("thiserror::Error")
+    @rustAttr("error(\"{code}: {message}\")")
+    @rustImpl("impl IntoResponse for ApiError { fn into_response(self) -> axum::response::Response { ... } }")
+    model ApiError { ... }
+    ```
+
+### Example
+
+```typespec
+import "typespec-rust-emitter";
+
+@rustImpl("impl IntoResponse for NotFoundError {
+    fn into_response(self) -> axum::response::Response {
+        (StatusCode::NOT_FOUND, Json(self)).into_response()
+    }
+}")
+model NotFoundError {
+  code: string;
+  message: string;
+}
+```
+
+Generates:
+
+```rust
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct NotFoundError {
+    pub code: String,
+    pub message: String,
+}
+
+impl IntoResponse for NotFoundError {
+    fn into_response(self) -> axum::response::Response {
+        (StatusCode::NOT_FOUND, Json(self)).into_response()
+    }
+}
+```
+
+## [0.9.0] - 2026-03-31
+
+### Changed
+
+- **Error `IntoResponse` now uses dynamic status code from `code` field**: Instead of mapping status codes by error type name, errors now use `StatusCode::from_str(&self.code)` to determine the HTTP status code at runtime
+  - This allows defining any error type with custom codes without changing the emitter
+  - Falls back to `INTERNAL_SERVER_ERROR` if the code is not a valid HTTP status string
+
+### Example
+
+```rust
+// Error model with any code
+model CustomError {
+  code: string;      // e.g., "NOT_FOUND", "BAD_REQUEST", "MY_CUSTOM_CODE"
+  message: string;
+}
+
+impl IntoResponse for CustomError {
+    fn into_response(self) -> axum::response::Response {
+        (
+            StatusCode::from_str(&self.code).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
+            Json(self),
+        )
+            .into_response()
+    }
+}
+```
+
+### Fixed
+
+- **Clippy warnings**: Enums and newtype structs with pattern validation now use `#[derive(Default)]` with `#[default]` attribute instead of manual `impl Default`, eliminating `clippy::derivable_impls` warnings
+
+### Internal
+
+- Added `use std::str::FromStr;` import to generated types.rs
+- Removed unused `getHttpStatusCodeForError()` function
+
 ## [0.8.0] - 2026-03-30
 
 ### Added

package/README.md

@@ -12,7 +12,7 @@ A TypeSpec emitter that generates idiomatic Rust types and structs from TypeSpec
 ## Features
 
 - **Models**: Converts TypeSpec models to Rust structs with serde derive macros
-- **Enums**: Supports both string and integer enums
+- **Enums**: Supports both string and integer enums with `Default` derive
 - **Unions**: Handles nullable types (`T | null` → `Option<T>`) and string literal unions
 - **Scalars**: Maps TypeSpec scalars to Rust equivalents with `@format` support
 - **Inheritance**: Supports model inheritance with `getAllProperties()`
@@ -78,8 +78,9 @@ enum Status {
 Generates:
 
 ```rust
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]
 pub enum Status {
+    #[default]
     #[serde(rename = "active")]
     Active,
     #[serde(rename = "inactive")]
@@ -87,12 +88,6 @@ pub enum Status {
     #[serde(rename = "pending")]
     Pending,
 }
-
-impl Default for Status {
-    fn default() -> Self {
-        Status::Active
-    }
-}
 ```
 
 ### Error Model
@@ -116,8 +111,20 @@ pub struct ApiError {
     #[serde(rename = "message")]
     pub message: String,
 }
+
+impl IntoResponse for ApiError {
+    fn into_response(self) -> axum::response::Response {
+        (
+            StatusCode::from_str(&self.code).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
+            Json(self),
+        )
+            .into_response()
+    }
+}
 ```
 
+Error codes are parsed dynamically, so any valid HTTP status code string (e.g., `"NOT_FOUND"`, `"BAD_REQUEST"`, `"418 I'M_A_TEAPOT"`) will work.
+
 ### UUID Format
 
 ```typespec
@@ -207,9 +214,10 @@ pub struct User {
     pub name: String,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize, sqlx::Type)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize, sqlx::Type)]
 #[sqlx(type_name = "study_status")]
 pub enum StudyStatus {
+    #[default]
     #[serde(rename = "Starting")]
     Starting,
     #[serde(rename = "Paused")]

package/dist/src/emitter.d.ts

@@ -6,4 +6,5 @@ export declare function $rustDerive(context: DecoratorContext, target: Type, der
 export declare function $rustDerives(context: DecoratorContext, target: Type, ...derives: string[]): void;
 export declare function $rustAttr(context: DecoratorContext, target: Type, attr: string): void;
 export declare function $rustAttrs(context: DecoratorContext, target: Type, ...attrs: string[]): void;
+export declare function $rustImpl(context: DecoratorContext, target: Type, impl: string): void;
 export declare function $onEmit(context: EmitContext<RustEmitterOptions>, _options?: RustEmitterOptions): Promise<void>;

package/dist/src/emitter.js

@@ -1,6 +1,7 @@
-import { emitFile, resolvePath, navigateProgram, getDoc, isArrayModelType, isRecordModelType, getFormat, getPattern, isErrorModel, getNamespaceFullName, getTags, } from "@typespec/compiler";
+import { emitFile, resolvePath, navigateProgram, getDoc, isArrayModelType, isRecordModelType, getFormat, getPattern, getNamespaceFullName, getTags, } from "@typespec/compiler";
 const rustDeriveKey = Symbol("rustDerive");
 const rustAttrKey = Symbol("rustAttr");
+const rustImplKey = Symbol("rustImpl");
 export function $rustDerive(context, target, derive) {
     if (target.kind !== "Model" && target.kind !== "Enum") {
         context.program.reportDiagnostic({
@@ -73,6 +74,22 @@ export function $rustAttrs(context, target, ...attrs) {
         $rustAttr(context, target, attr);
     }
 }
+export function $rustImpl(context, target, impl) {
+    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[rustImplKey] = { impl: impl };
+    }
+}
 function getDecoratorName(decorator) {
     if (!decorator)
         return "";
@@ -410,15 +427,6 @@ function getHttpStatusCode(statusCode) {
     };
     return statusCodes[statusCode] || `StatusCode::from_u16(${statusCode})`;
 }
-function getHttpStatusCodeForError(errorName) {
-    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, namespaceGroups, anonymousEnums) {
     const parts = [];
     parts.push(`use super::types::*;
@@ -880,24 +888,24 @@ function emitStringLiteralUnion(union) {
     const parts = [];
     const name = toPascalCase(union.name ?? "Value");
     const variants = Array.from(union.variants.values());
-    parts.push(`#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]\npub enum ${name} {`);
-    for (const variant of variants) {
-        const literalType = variant.type;
+    parts.push(`#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\npub enum ${name} {`);
+    for (let i = 0; i < variants.length; i++) {
+        const literalType = variants[i].type;
         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.value : "");
-    parts.push(`\n\nimpl Default for ${name} {\n  fn default() -> Self {\n    ${name}::${defaultVariant}\n  }\n}`);
     return parts.join("\n");
 }
 function emitModel(model, program, anonymousEnums) {
     const parts = [];
     const name = toPascalCase(model.name);
     const allProps = getAllProperties(model, program);
-    const isError = isErrorModel(program, model);
     const deriveAttrs = [
         "Debug",
         "Clone",
@@ -909,13 +917,7 @@ function emitModel(model, program, anonymousEnums) {
     if (customDerives) {
         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[rustAttrKey];
     if (customAttrs) {
@@ -950,14 +952,11 @@ ${fields.join("\n")}
         parts.push(`pub struct ${name}`);
         parts.push("(());");
     }
-    if (isError && allProps.size > 0) {
-        const statusCode = getHttpStatusCodeForError(name);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const customImpl = model[rustImplKey];
+    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");
 }
@@ -986,6 +985,7 @@ function emitEnum(enumType) {
         "PartialEq",
         "Eq",
         "Hash",
+        "Default",
         "serde::Serialize",
         "serde::Deserialize",
     ];
@@ -1009,9 +1009,12 @@ function emitEnum(enumType) {
             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},`);
         }
@@ -1022,15 +1025,16 @@ function emitEnum(enumType) {
             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");
 }
 function emitUnion(union, program) {
@@ -1065,9 +1069,8 @@ function emitScalar(scalar, program) {
     if (pattern) {
         const rustType = scalarToRust[scalar.name] ?? "String";
         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,
         };
     }
@@ -1131,15 +1134,17 @@ export async function $onEmit(context, _options) {
     }
     for (const [enumName, anonEnum] of anonymousEnums) {
         const parts = [];
-        parts.push(`#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]\npub enum ${enumName} {`);
-        for (const literal of anonEnum.variants) {
+        parts.push(`#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\npub enum ${enumName} {`);
+        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("");
     }
@@ -1165,6 +1170,7 @@ export async function $onEmit(context, _options) {
     }
     const namespaceGroups = getAllOperations(context.program);
     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" +