typespec-rust-emitter 0.1.0

package/README.md

@@ -0,0 +1,220 @@
+Authored by [opencode](https://opencode.ai)
+
+---
+
+# TypeSpec Rust Emitter
+
+A TypeSpec emitter that generates idiomatic Rust types and structs from TypeSpec specifications.
+
+[![npm version](https://img.shields.io/npm/v/typespec-rust-emitter.svg)](https://www.npmjs.com/package/typespec-rust-emitter)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- **Models**: Converts TypeSpec models to Rust structs with serde derive macros
+- **Enums**: Supports both string and integer enums
+- **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()`
+- **Error Models**: Generates `thiserror::Error` derive with `#[error(...)]` attributes
+- **Pattern Validation**: Supports `@pattern` decorators with `TryFrom<String>` validation
+- **Custom Derives**: Add arbitrary Rust derive macros via `@rustDerive` decorator
+
+## Installation
+
+```bash
+npm install typespec-rust-emitter
+```
+
+### Peer Dependencies
+
+This package requires the following peer dependencies:
+
+```bash
+npm install @typespec/compiler @typespec/emitter-framework
+```
+
+## Usage
+
+## Usage
+
+### Basic Model
+
+```typespec
+import "typespec-emitter";
+
+model User {
+  name: string;
+  age: int32;
+  email: string | null;
+}
+```
+
+Generates:
+
+```rust
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct User {
+    #[serde(rename = "name")]
+    pub name: String,
+    #[serde(rename = "age")]
+    pub age: i32,
+    #[serde(rename = "email")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub email: Option<String>,
+}
+```
+
+### String Enum
+
+```typespec
+enum Status {
+  active,
+  inactive,
+  pending,
+}
+```
+
+Generates:
+
+```rust
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+pub enum Status {
+    #[serde(rename = "active")]
+    Active,
+    #[serde(rename = "inactive")]
+    Inactive,
+    #[serde(rename = "pending")]
+    Pending,
+}
+
+impl Default for Status {
+    fn default() -> Self {
+        Status::Active
+    }
+}
+```
+
+### Error Model
+
+```typespec
+@error
+model ApiError {
+  code: string;
+  message: string;
+}
+```
+
+Generates:
+
+```rust
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, thiserror::Error)]
+#[error("{code}: {message}")]
+pub struct ApiError {
+    #[serde(rename = "code")]
+    pub code: String,
+    #[serde(rename = "message")]
+    pub message: String,
+}
+```
+
+### UUID Format
+
+```typespec
+@format("uuid")
+scalar Uuid extends string;
+```
+
+Generates:
+
+```rust
+pub type Uuid = uuid::Uuid;
+```
+
+### Pattern Validation
+
+```typespec
+@pattern("^#[0-9A-Fa-f]{6}$")
+scalar HexColor extends string;
+```
+
+Generates:
+
+```rust
+#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+pub struct HexColor(pub String);
+
+impl TryFrom<String> for HexColor {
+    type Error = String;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        let re = regex::Regex::new(r"^#[0-9A-Fa-f]{6}$").unwrap();
+        if re.is_match(&value) { Ok(Self(value)) } else { Err(format!("Invalid value: {}", value)) }
+    }
+}
+```
+
+### Custom Derives
+
+```typespec
+import "typespec-emitter";
+
+@rustDerive("sqlx::FromRow")
+@rustDerive("derive_more::Display")
+model GroupStatistics {
+  id: int64;
+  name: string;
+}
+```
+
+Generates:
+
+```rust
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, sqlx::FromRow, derive_more::Display)]
+pub struct GroupStatistics {
+    #[serde(rename = "id")]
+    pub id: i64,
+    #[serde(rename = "name")]
+    pub name: String,
+}
+```
+
+## Type Mappings
+
+| TypeSpec Type    | Rust Type                                   |
+| ---------------- | ------------------------------------------- |
+| `string`         | `String`                                    |
+| `int32`          | `i32`                                       |
+| `int64`          | `i64`                                       |
+| `float32`        | `f32`                                       |
+| `float64`        | `f64`                                       |
+| `boolean`        | `bool`                                      |
+| `string[]`       | `Vec<String>`                               |
+| `Record<string>` | `std::collections::HashMap<String, String>` |
+| `T \| null`      | `Option<T>`                                 |
+
+## Building
+
+```bash
+npm run build
+```
+
+## Testing
+
+```bash
+npm test
+```
+
+## Development
+
+The emitter is built using the TypeSpec emitter framework. Key files:
+
+- `src/emitter.ts` - Main emitter implementation
+- `src/lib.tsp` - TypeSpec decorator declarations
+- `src/index.ts` - Public exports
+- `test/hello.test.ts` - Unit tests
+- `example/` - Example TypeSpec definitions and generated Rust output
+
+## License
+
+MIT

package/dist/src/emitter.d.ts

@@ -0,0 +1,7 @@
+import { EmitContext, Type, DecoratorContext } from "@typespec/compiler";
+export interface RustEmitterOptions {
+    moduleName?: string;
+}
+export declare function $rustDerive(context: DecoratorContext, target: Type, derive: string): void;
+export declare function $rustDerives(context: DecoratorContext, target: Type, ...derives: string[]): void;
+export declare function $onEmit(context: EmitContext<RustEmitterOptions>, _options?: RustEmitterOptions): Promise<void>;