typespec-rust-emitter 0.1.0

package/test/hello.test.ts

@@ -0,0 +1,168 @@
+import { strictEqual } from "node:assert";
+import { describe, it } from "node:test";
+import { emit } from "./test-host.js";
+
+describe("Rust emitter", () => {
+  it("emits basic model", async () => {
+    const results = await emit(`
+      model User {
+        name: string;
+        age: int32;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes("pub struct User"), true);
+    strictEqual(output.includes("pub name: String,"), true);
+    strictEqual(output.includes("pub age: i32,"), true);
+  });
+
+  it("emits optional properties", async () => {
+    const results = await emit(`
+      model Person {
+        firstName: string;
+        middleName?: string;
+        lastName: string;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes('#[serde(rename = "firstName")]'), true);
+    strictEqual(output.includes("pub first_name: String,"), true);
+    strictEqual(output.includes('#[serde(rename = "middleName")]'), true);
+    strictEqual(output.includes("pub middle_name: Option<String>,"), true);
+    strictEqual(output.includes("#[serde(skip_serializing_if"), true);
+    strictEqual(output.includes('#[serde(rename = "lastName")]'), true);
+    strictEqual(output.includes("pub last_name: String,"), true);
+  });
+
+  it("emits string enum", async () => {
+    const results = await emit(`
+      enum Status {
+        active,
+        inactive,
+        pending,
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes("pub enum Status"), true);
+    strictEqual(output.includes('#[serde(rename = "active")]'), true);
+    strictEqual(output.includes("Active,"), true);
+    strictEqual(output.includes("Inactive,"), true);
+    strictEqual(output.includes("Pending,"), true);
+  });
+
+  it("emits integer enum", async () => {
+    const results = await emit(`
+      enum Priority {
+        low: 1,
+        medium: 2,
+        high: 3,
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes("pub enum Priority"), true);
+    strictEqual(output.includes("Low = 1,"), true);
+    strictEqual(output.includes("Medium = 2,"), true);
+    strictEqual(output.includes("High = 3,"), true);
+  });
+
+  it("emits nested models", async () => {
+    const results = await emit(`
+      model Address {
+        street: string;
+        city: string;
+      }
+      
+      model User {
+        name: string;
+        address: Address;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes("pub struct Address"), true);
+    strictEqual(output.includes("pub struct User"), true);
+    strictEqual(output.includes("pub address: Address,"), true);
+  });
+
+  it("includes serde derive macros", async () => {
+    const results = await emit(`
+      model Test {
+        value: string;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(
+      output.includes(
+        "#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]",
+      ),
+      true,
+    );
+  });
+
+  it("emits arrays as Vec", async () => {
+    const results = await emit(`
+      model Test {
+        items: string[];
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes("pub items: Vec<String>,"), true);
+  });
+
+  it("emits maps as HashMap", async () => {
+    const results = await emit(`
+      model Test {
+        metadata: Record<string>;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(
+      output.includes("std::collections::HashMap<String, String>"),
+      true,
+    );
+  });
+
+  it("emits nullable types as Option", async () => {
+    const results = await emit(`
+      model Test {
+        deletedAt: string | null;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(output.includes('#[serde(rename = "deletedAt")]'), true);
+    strictEqual(output.includes("pub deleted_at: Option<String>,"), true);
+  });
+
+  it("emits custom rustDerive macros", async () => {
+    const results = await emit(`
+      import "typespec-rust-emitter";
+      
+      @rustDerive("sqlx::FromRow")
+      model User {
+        name: string;
+        age: int32;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(
+      output.includes(
+        "#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, sqlx::FromRow)]",
+      ),
+      true,
+    );
+  });
+
+  it("emits multiple rustDerive macros via $rustDerives", async () => {
+    const results = await emit(`
+      model Statistics {
+        count: int32;
+      }
+    `);
+    const output = results["types.rs"];
+    strictEqual(
+      output.includes(
+        "#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]",
+      ),
+      true,
+    );
+  });
+});

package/test/test-host.ts

@@ -0,0 +1,20 @@
+import { Diagnostic, resolvePath } from "@typespec/compiler";
+import { expectDiagnosticEmpty } from "@typespec/compiler/testing";
+import { createTester } from "@typespec/compiler/testing";
+
+export const Tester = createTester(resolvePath(import.meta.dirname, "../.."), {
+  libraries: ["typespec-rust-emitter"],
+}).emit("typespec-rust-emitter");
+
+export async function emitWithDiagnostics(
+  code: string,
+): Promise<[Record<string, string>, readonly Diagnostic[]]> {
+  const [{ outputs }, diagnostics] = await Tester.compileAndDiagnose(code);
+  return [outputs, diagnostics];
+}
+
+export async function emit(code: string): Promise<Record<string, string>> {
+  const [result, diagnostics] = await emitWithDiagnostics(code);
+  expectDiagnosticEmpty(diagnostics);
+  return result;
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "rootDir": ".",
+    "outDir": "dist",
+    "sourceMap": true,
+    "declaration": true,
+    "skipLibCheck": true,
+
+    /* Linting */
+    "strict": true
+  },
+  "include": ["src", "test"]
+}