typespec-rust-emitter 0.11.0 → 0.13.0

package/src/generator/server_trait.ts

@@ -0,0 +1,134 @@
+import { Operation, Program, Namespace } from "@typespec/compiler";
+import { AnonymousStringLiteralUnion } from "../models/types.js";
+import { formatDoc, toPascalCase, toRustIdent } from "../formatter/strings.js";
+import {
+  emitOperationInfo,
+  hasAuthDecorator,
+  getSelfReceiver,
+  hasEtagCache,
+} from "../parser/operations.js";
+import { getRustTypeForProperty } from "../parser/types.js";
+import { hasMultipartBody } from "../parser/parameters.js";
+import { generateEtagCacheTrait } from "./etag_router.js";
+
+export function generateServerTrait(
+  program: Program,
+  namespaceGroups: { namespace: Namespace; operations: Operation[] }[],
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): string {
+  const parts: string[] = [];
+
+  parts.push(`use super::types::*;
+use async_trait::async_trait;
+use axum::extract::Path;
+use axum::Extension;
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use axum::Json;
+use eyre::Result;
+
+`);
+
+  if (namespaceGroups.some((g) => g.operations.some((o) => hasEtagCache(program, o)))) {
+    parts.push(generateEtagCacheTrait());
+    parts.push("\n");
+  }
+
+  parts.push(`#[async_trait]
+pub trait Server: Send + Sync {
+    type Claims: Send + Sync + 'static;
+
+`);
+
+  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;
+
+      if (opInfo.doc) {
+        parts.push(`    ${formatDoc(opInfo.doc)}`);
+      }
+
+      const responseName = `${nsName}${toPascalCase(opInfo.name)}Response`;
+      const fnName = toRustIdent(`${nsName}_${opInfo.name}`);
+      const isProtected = hasAuthDecorator(op);
+
+      // Build parameter list for the trait method
+      const paramParts: string[] = [];
+
+      // Add path parameters
+      for (const param of opInfo.parameters) {
+        if (param.location === "path") {
+          paramParts.push(`${param.rustName}: ${param.rustType}`);
+        }
+      }
+
+      // Add query parameters
+      for (const param of opInfo.parameters) {
+        if (param.location === "query") {
+          paramParts.push(`${param.rustName}: ${param.rustType}`);
+        }
+      }
+
+      // Add body parameter
+      if (opInfo.body) {
+        if (hasMultipartBody(op)) {
+          paramParts.push(`body: Multipart`);
+        } else {
+          const bodyType = getRustTypeForProperty(
+            opInfo.body.type,
+            program,
+            anonymousEnums,
+          );
+          paramParts.push(`body: ${bodyType.type}`);
+        }
+      }
+
+      const paramsStr = paramParts.join(", ");
+      const selfReceiver = getSelfReceiver(op);
+
+      if (hasEtagCache(program, op)) {
+        const paramList = paramsStr ? `cache: &C, ${paramsStr}` : `cache: &C`;
+        if (isProtected) {
+          parts.push(
+            `    async fn ${fnName}<C: EtagCache + Send + Sync>(\n        ${selfReceiver}, claims: Self::Claims, ${paramList}\n    ) -> Result<${responseName}>;`,
+          );
+        } else {
+          parts.push(
+            `    async fn ${fnName}<C: EtagCache + Send + Sync>(\n        ${selfReceiver}, ${paramList}\n    ) -> Result<${responseName}>;`,
+          );
+        }
+      } else {
+        if (isProtected) {
+          if (paramsStr) {
+            parts.push(
+              `    async fn ${fnName}(${selfReceiver}, claims: Self::Claims, ${paramsStr}) -> Result<${responseName}>;`,
+            );
+          } else {
+            parts.push(
+              `    async fn ${fnName}(${selfReceiver}, claims: Self::Claims) -> Result<${responseName}>;`,
+            );
+          }
+        } else {
+          if (paramsStr) {
+            parts.push(
+              `    async fn ${fnName}(${selfReceiver}, ${paramsStr}) -> Result<${responseName}>;`,
+            );
+          } else {
+            parts.push(
+              `    async fn ${fnName}(${selfReceiver}) -> Result<${responseName}>;`,
+            );
+          }
+        }
+      }
+    }
+  }
+
+  parts.push("}");
+
+  return parts.join("\n");
+}

package/src/generator/types_file.ts

@@ -0,0 +1,297 @@
+import {
+  Enum,
+  getDoc,
+  getFormat,
+  getPattern,
+  Model,
+  ModelProperty,
+  Program,
+  Scalar,
+  StringLiteral,
+  Union,
+} from "@typespec/compiler";
+import {
+  AnonymousStringLiteralUnion,
+  RustAttrInfo,
+  RustDeriveInfo,
+  RustImplInfo,
+} from "../models/types.js";
+import { rustAttrKey, rustDeriveKey, rustImplKey } from "../models/keys.js";
+import { formatToRust, scalarToRust } from "../formatter/mappings.js";
+import {
+  formatDoc,
+  toPascalCase,
+  toRustIdent,
+  toRustVariantName,
+} from "../formatter/strings.js";
+import { getRustTypeForProperty } from "../parser/types.js";
+
+export function getAllProperties(
+  model: Model,
+  _program: Program,
+): Map<string, ModelProperty> {
+  const props = new Map<string, ModelProperty>();
+
+  if (model.baseModel) {
+    const baseProps = getAllProperties(model.baseModel, _program);
+    for (const [key, value] of baseProps) {
+      props.set(key, value);
+    }
+  }
+
+  for (const [key, value] of model.properties) {
+    props.set(key, value);
+  }
+
+  return props;
+}
+
+export function emitModel(
+  model: Model,
+  program: Program,
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): string {
+  const parts: string[] = [];
+  const name = toPascalCase(model.name);
+  const allProps = getAllProperties(model, program);
+
+  const deriveAttrs = [
+    "Debug",
+    "Clone",
+    "serde::Serialize",
+    "serde::Deserialize",
+  ];
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const customDerives = (model as any)[rustDeriveKey] as
+    | RustDeriveInfo
+    | undefined;
+  if (customDerives) {
+    deriveAttrs.push(...customDerives.derives);
+  }
+
+  parts.push(`#[derive(${deriveAttrs.join(", ")})]`);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  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) {
+      const doc = getDoc(program, prop);
+      const { type: rustType } = getRustTypeForProperty(
+        prop.type,
+        program,
+        anonymousEnums,
+      );
+      const optional = prop.optional ? true : false;
+      const fieldName = toRustIdent(propName);
+      const serdeRename =
+        propName !== fieldName ? `#[serde(rename = "${propName}")]` : "";
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const propAttrs = (prop as any)[rustAttrKey] as RustAttrInfo | undefined;
+
+      if (doc) {
+        fields.push(`  ${formatDoc(doc)}`);
+      }
+      if (propAttrs) {
+        for (const attr of propAttrs.attrs) {
+          fields.push(`  #[${attr}]`);
+        }
+      }
+      if (serdeRename) {
+        fields.push(`  ${serdeRename}`);
+      }
+      if (optional) {
+        fields.push(`  #[serde(skip_serializing_if = "Option::is_none")]`);
+      }
+      fields.push(
+        `  pub ${fieldName}: ${optional ? `Option<${rustType}>` : rustType},`,
+      );
+    }
+    parts.push(`pub struct ${name} {
+${fields.join("\n")}
+}`);
+  } else {
+    parts.push(`pub struct ${name}`);
+    parts.push("(());");
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const customImpl = (model as any)[rustImplKey] as RustImplInfo | undefined;
+  if (customImpl) {
+    parts.push(`
+${customImpl.impl}`);
+  }
+
+  return parts.join("\n");
+}
+
+export function emitEnum(enumType: Enum): string {
+  const parts: string[] = [];
+  const name = toPascalCase(enumType.name);
+  const members = Array.from(enumType.members.values());
+  const isString = members.every(
+    (m) => m.value === undefined || typeof m.value === "string",
+  );
+
+  const baseDerives = [
+    "Debug",
+    "Clone",
+    "Copy",
+    "PartialEq",
+    "Eq",
+    "Hash",
+    "Default",
+    "serde::Serialize",
+    "serde::Deserialize",
+  ];
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const customDerives = (enumType as any)[rustDeriveKey] as
+    | RustDeriveInfo
+    | undefined;
+  const allDerives = [...baseDerives];
+  if (customDerives) {
+    allDerives.push(...customDerives.derives);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  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(${allDerives.join(", ")})]`);
+    if (attrLines.length > 0) {
+      parts.push(...attrLines);
+    }
+    parts.push(`pub enum ${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},`);
+    }
+  } else {
+    parts.push(`#[derive(${allDerives.join(", ")})]`);
+    if (attrLines.length > 0) {
+      parts.push(...attrLines);
+    }
+    parts.push(`pub enum ${name} {`);
+    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("}");
+  return parts.join("\n");
+}
+
+export function emitUnion(union: Union, program: Program): string {
+  const parts: string[] = [];
+  const name = toPascalCase(union.name ?? "Union");
+
+  const variants = Array.from(union.variants.values());
+  if (variants.length === 0) {
+    parts.push(
+      `#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]\npub enum ${name} {}\nimpl ${name} {\n  pub fn new() -> Self { unreachable!() }\n}`,
+    );
+    return parts.join("\n");
+  }
+
+  parts.push(
+    `#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]\n#[serde(untagged)]\npub enum ${name} {`,
+  );
+  for (let i = 0; i < variants.length; i++) {
+    const variant = variants[i];
+    const variantName = `Variant${i + 1}`;
+    const { type: rustType } = getRustTypeForProperty(
+      variant.type,
+      program,
+      new Map(),
+    );
+    parts.push(`  ${variantName}(${rustType}),`);
+  }
+  parts.push("}");
+
+  return parts.join("\n");
+}
+
+export function emitScalar(
+  scalar: Scalar,
+  program: Program,
+): { typeDef: string; impls: string[] } {
+  const format = getFormat(program, scalar);
+  const pattern = getPattern(program, scalar);
+  const structName = toPascalCase(scalar.name);
+  const impls: string[] = [];
+
+  if (format && formatToRust[format]) {
+    return {
+      typeDef: `pub type ${structName} = ${formatToRust[format]};`,
+      impls: [],
+    };
+  }
+
+  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}`,
+    );
+
+    return {
+      typeDef: `#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\npub struct ${structName}(pub ${rustType});`,
+      impls,
+    };
+  }
+
+  const rustType = scalarToRust[scalar.name] ?? "serde_json::Value";
+  return {
+    typeDef: `pub type ${structName} = ${rustType};`,
+    impls: [],
+  };
+}
+
+export function emitStringLiteralUnion(union: Union): string {
+  const parts: string[] = [];
+  const name = toPascalCase(union.name ?? "Value");
+  const variants = Array.from(union.variants.values());
+
+  parts.push(
+    `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\n#[allow(clippy::enum_variant_names)]\npub enum ${name} {`,
+  );
+
+  for (let i = 0; i < variants.length; i++) {
+    const literalType = variants[i].type as StringLiteral;
+    const variantName = toPascalCase(literalType.value);
+    const serdeValue = literalType.value;
+    if (i === 0) {
+      parts.push(`  #[default]`);
+    }
+    parts.push(`  #[serde(rename = "${serdeValue}")]`);
+    parts.push(`  ${variantName},`);
+  }
+
+  parts.push("}");
+  return parts.join("\n");
+}

package/src/index.ts

@@ -7,5 +7,7 @@ export {
   $rustImpl,
   $rustMut,
   $rustOwn,
-} from "./emitter.js";
+  $etagCache,
+  $cacheControl,
+} from "./decorators/index.js";
 export { $lib } from "./lib.js";

package/src/lib.ts

@@ -1,7 +1,7 @@
 import { createTypeSpecLibrary } from "@typespec/compiler";
 
 export const $lib = createTypeSpecLibrary({
-  name: "typespec-emitter",
+  name: "typespec-rust-emitter",
   diagnostics: {},
 });
 

package/src/lib.tsp

@@ -1,4 +1,4 @@
-import "../dist/src/emitter.js";
+import "../dist/src/index.js";
 
 using TypeSpec.Reflection;
 
@@ -9,3 +9,5 @@ extern dec rustAttrs(target: Model | Enum | ModelProperty, ...attrs: valueof str
 extern dec rustImpl(target: Model, impl: valueof string);
 extern dec rustMut(target: Operation);
 extern dec rustOwn(target: Operation);
+extern dec etagCache(target: Operation, etagKey?: valueof string);
+extern dec cacheControl(target: Operation, value: valueof string);

package/src/models/index.ts

@@ -0,0 +1,2 @@
+export * from "./keys.js";
+export * from "./types.js";

package/src/models/keys.ts

@@ -0,0 +1,7 @@
+// All Symbol keys that decorators store on TypeSpec Type objects.
+export const rustDeriveKey = Symbol("rustDerive");
+export const rustAttrKey = Symbol("rustAttr");
+export const rustImplKey = Symbol("rustImpl");
+export const rustSelfReceiverKey = Symbol("rustSelfReceiver");
+export const etagCacheKey = Symbol("etagCache");
+export const cacheControlKey = Symbol("cacheControl");

package/src/models/types.ts

@@ -0,0 +1,54 @@
+import type { ModelProperty, StringLiteral } from "@typespec/compiler";
+
+export interface RustEmitterOptions {
+  moduleName?: string;
+}
+
+export type SelfReceiver = "&self" | "&mut self" | "self";
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
+
+export interface RustDeriveInfo {
+  derives: string[];
+}
+
+export interface RustAttrInfo {
+  attrs: string[];
+}
+
+export interface RustImplInfo {
+  impl: string;
+}
+
+export interface ParameterInfo {
+  name: string;
+  rustName: string;
+  rustType: string;
+  location: "path" | "query" | "header" | "cookie";
+  required: boolean;
+  optional?: boolean;
+}
+
+export interface ResponseInfo {
+  statusCode: number;
+  bodyType: string | undefined;
+  bodyDescription: string | undefined;
+  isSse?: boolean;
+}
+
+export interface OperationInfo {
+  name: string;
+  method: HttpMethod;
+  path: string;
+  tags: string[];
+  parameters: ParameterInfo[];
+  body: ModelProperty | undefined;
+  responses: ResponseInfo[];
+  doc: string | undefined;
+  etagKey?: string;
+  cacheControl?: string;
+}
+
+export interface AnonymousStringLiteralUnion {
+  enumName: string;
+  variants: StringLiteral[];
+}

package/src/parser/decorators.ts

@@ -0,0 +1,34 @@
+export function getDecoratorName(decorator: {
+  node?: { target?: { sv?: string; kind?: string } };
+}): string {
+  if (!decorator) return "";
+  if (typeof decorator !== "object") return "";
+
+  if (decorator.node?.target?.sv) {
+    return decorator.node.target.sv;
+  }
+  if (
+    decorator.node?.target?.kind === "Identifier" &&
+    decorator.node?.target?.sv
+  ) {
+    return decorator.node.target.sv;
+  }
+
+  return "";
+}
+
+export function getDecoratorArgValue(
+  decorator: {
+    args?: { jsValue?: unknown; value?: unknown }[];
+    arguments?: { jsValue?: unknown; value?: unknown }[];
+  },
+  index: number = 0,
+): string {
+  if (!decorator) return "";
+  const args = decorator.args || decorator.arguments;
+  if (!args) return "";
+  const arg = args[index];
+  if (arg?.jsValue !== undefined) return String(arg.jsValue);
+  if (arg?.value !== undefined) return String(arg.value);
+  return "";
+}

package/src/parser/index.ts

@@ -0,0 +1,6 @@
+export * from "./decorators.js";
+export * from "./routes.js";
+export * from "./types.js";
+export * from "./parameters.js";
+export * from "./responses.js";
+export * from "./operations.js";