typespec-rust-emitter 0.12.0 → 0.13.0

package/src/parser/operations.ts

@@ -0,0 +1,158 @@
+import {
+  getDoc,
+  getNamespaceFullName,
+  getTags,
+  Namespace,
+  navigateProgram,
+  Operation,
+  Program,
+} from "@typespec/compiler";
+import {
+  AnonymousStringLiteralUnion,
+  OperationInfo,
+  SelfReceiver,
+} from "../models/types.js";
+import {
+  cacheControlKey,
+  etagCacheKey,
+  rustSelfReceiverKey,
+} from "../models/keys.js";
+import { getDecoratorName } from "./decorators.js";
+import { buildFullPath, getRoute } from "./routes.js";
+import { getOperationParameters, getOperationBody } from "./parameters.js";
+import { getOperationResponses } from "./responses.js";
+
+export function hasAuthDecorator(operation: Operation): boolean {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const decorators = (operation as any).decorators;
+  if (!decorators) return false;
+
+  for (const key of Object.keys(decorators)) {
+    const decorator = decorators[key];
+    const name = getDecoratorName(decorator);
+    if (name === "useAuth") {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function getSelfReceiver(operation: Operation): SelfReceiver {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const receiver = (operation as any)[rustSelfReceiverKey] as
+    | SelfReceiver
+    | undefined;
+  return receiver ?? "&self";
+}
+
+export function getHttpMethod(
+  _program: Program,
+  operation: Operation,
+): "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | undefined {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const decorators = (operation as any).decorators;
+  if (!decorators) return undefined;
+
+  for (const key of Object.keys(decorators)) {
+    const decorator = decorators[key];
+    const name = getDecoratorName(decorator);
+    if (name === "get") return "GET";
+    if (name === "post") return "POST";
+    if (name === "put") return "PUT";
+    if (name === "patch") return "PATCH";
+    if (name === "delete") return "DELETE";
+    if (name === "head") return "HEAD";
+  }
+  return undefined;
+}
+
+export function getAllOperations(
+  program: Program,
+): { namespace: Namespace; operations: Operation[] }[] {
+  const seenNamespaces = new Set<string>();
+  const namespaceOps = new Map<string, { ns: Namespace; ops: Operation[] }>();
+
+  navigateProgram(program, {
+    namespace(ns: Namespace) {
+      const route = getRoute(program, ns);
+      if (!route) return;
+      const fullName = getNamespaceFullName(ns);
+      if (!seenNamespaces.has(fullName)) {
+        seenNamespaces.add(fullName);
+        namespaceOps.set(fullName, { ns, ops: [] });
+      }
+    },
+    operation(op: Operation) {
+      const method = getHttpMethod(program, op);
+      if (!method) return;
+      const ns = op.namespace;
+      if (!ns) return;
+      const fullName = getNamespaceFullName(ns);
+      if (!seenNamespaces.has(fullName)) {
+        seenNamespaces.add(fullName);
+        namespaceOps.set(fullName, { ns, ops: [] });
+      }
+      const entry = namespaceOps.get(fullName);
+      if (entry) {
+        entry.ops.push(op);
+      }
+    },
+  });
+
+  const result: { namespace: Namespace; operations: Operation[] }[] = [];
+  for (const [, entry] of namespaceOps) {
+    if (entry.ops.length > 0) {
+      result.push({ namespace: entry.ns, operations: entry.ops });
+    }
+  }
+  return result;
+}
+
+export function emitOperationInfo(
+  program: Program,
+  op: Operation,
+  nsRoute: string,
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): OperationInfo | undefined {
+  const method = getHttpMethod(program, op);
+  if (!method) return undefined;
+
+  const opRoute = getRoute(program, op);
+  const fullPath = buildFullPath(nsRoute, opRoute);
+  const tags = getTags(program, op) ?? [];
+  const params = getOperationParameters(program, op, anonymousEnums);
+  const body = getOperationBody(op);
+  const responses = getOperationResponses(program, op, anonymousEnums);
+  const doc = getDoc(program, op);
+
+  const opName = op.name.replace(/[^a-zA-Z0-9_]/g, "_");
+  const etagVal = program.stateMap(etagCacheKey).get(op);
+  const etagKey = typeof etagVal === "string" ? etagVal : undefined;
+  const cacheControl = program.stateMap(cacheControlKey).get(op) as string | undefined;
+
+  return {
+    name: opName,
+    method,
+    path: fullPath,
+    tags,
+    parameters: params,
+    body: body,
+    responses,
+    doc,
+    etagKey,
+    cacheControl,
+  };
+}
+
+export function getEtagKey(program: Program, operation: Operation): string | undefined {
+  const val = program.stateMap(etagCacheKey).get(operation);
+  return typeof val === "string" ? val : undefined;
+}
+
+export function hasEtagCache(program: Program, operation: Operation): boolean {
+  return program.stateMap(etagCacheKey).has(operation);
+}
+
+export function getCacheControl(program: Program, operation: Operation): string | undefined {
+  return program.stateMap(cacheControlKey).get(operation) as string | undefined;
+}

package/src/parser/parameters.ts

@@ -0,0 +1,117 @@
+import { ModelProperty, Operation, Program } from "@typespec/compiler";
+import { AnonymousStringLiteralUnion, ParameterInfo } from "../models/types.js";
+import { toRustIdent } from "../formatter/strings.js";
+import { getDecoratorArgValue, getDecoratorName } from "./decorators.js";
+import { getRustTypeForProperty } from "./types.js";
+
+export function getOperationParameters(
+  program: Program,
+  operation: Operation,
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): ParameterInfo[] {
+  const params: ParameterInfo[] = [];
+  const model = operation.parameters;
+
+  for (const [propName, prop] of model.properties) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const decorators = (prop as any).decorators;
+
+    // Skip body parameters - they are handled separately
+    let isBody = false;
+    if (decorators) {
+      for (const key of Object.keys(decorators)) {
+        const decorator = decorators[key];
+        const name = getDecoratorName(decorator);
+        if (
+          name === "body" ||
+          name === "bodyRoot" ||
+          name === "multipartBody"
+        ) {
+          isBody = true;
+          break;
+        }
+      }
+    }
+    if (isBody) continue;
+
+    let location: "path" | "query" | "header" | "cookie" = "query";
+    let rustName = toRustIdent(propName);
+
+    if (decorators) {
+      for (const key of Object.keys(decorators)) {
+        const decorator = decorators[key];
+        const name = getDecoratorName(decorator);
+        if (name === "path") {
+          location = "path";
+          break;
+        } else if (name === "query") {
+          location = "query";
+          break;
+        } else if (name === "header") {
+          location = "header";
+          const headerVal = getDecoratorArgValue(decorator, 0);
+          if (headerVal) {
+            rustName = toRustIdent(headerVal);
+          }
+          break;
+        } else if (name === "cookie") {
+          location = "cookie";
+          break;
+        }
+      }
+    }
+
+    const { type: rustType } = getRustTypeForProperty(
+      prop.type,
+      program,
+      anonymousEnums,
+    );
+
+    params.push({
+      name: propName,
+      rustName,
+      rustType,
+      location,
+      required: !prop.optional,
+      optional: prop.optional,
+    });
+  }
+
+  return params;
+}
+
+export function getOperationBody(
+  operation: Operation,
+): ModelProperty | undefined {
+  for (const [_propName, prop] of operation.parameters.properties) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const decorators = (prop as any).decorators;
+    if (!decorators) continue;
+
+    for (const key of Object.keys(decorators)) {
+      const decorator = decorators[key];
+      const name = getDecoratorName(decorator);
+      if (name === "body" || name === "bodyRoot" || name === "multipartBody") {
+        return prop;
+      }
+    }
+  }
+  return undefined;
+}
+
+export function hasMultipartBody(operation: Operation): boolean {
+  for (const [_propName, prop] of operation.parameters.properties) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const decorators = (prop as any).decorators;
+    if (!decorators) continue;
+
+    for (const key of Object.keys(decorators)) {
+      const decorator = decorators[key];
+      const name = getDecoratorName(decorator);
+      if (name === "multipartBody") {
+        return true;
+      }
+    }
+  }
+  return false;
+}

package/src/parser/responses.ts

@@ -0,0 +1,170 @@
+import {
+  getDoc,
+  Model,
+  Operation,
+  Program,
+  Type,
+  Union,
+} from "@typespec/compiler";
+import { AnonymousStringLiteralUnion, ResponseInfo } from "../models/types.js";
+import { getDecoratorName } from "./decorators.js";
+import { getRustTypeForProperty } from "./types.js";
+
+export function getOperationResponses(
+  program: Program,
+  operation: Operation,
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): ResponseInfo[] {
+  const responses: ResponseInfo[] = [];
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const returnType = operation.returnType as any;
+
+  // Check for Array return type first (use runtime check since TS doesn't narrow Array)
+  if (
+    returnType.kind !== "Union" &&
+    returnType.kind !== "Model" &&
+    returnType.valueType
+  ) {
+    // This is an Array type
+    const { type: rustType } = getRustTypeForProperty(
+      returnType.valueType,
+      program,
+      anonymousEnums,
+    );
+    responses.push({
+      statusCode: 200,
+      bodyType: rustType,
+      bodyDescription: "",
+    });
+    return responses;
+  }
+
+  if (returnType.kind === "Union") {
+    const union = returnType as Union;
+    for (const variant of union.variants.values()) {
+      const statusCode = getStatusCode(variant);
+      const bodyInfo = getBodyFromResponse(variant, program, anonymousEnums);
+      responses.push({
+        statusCode,
+        bodyType: bodyInfo.type,
+        bodyDescription: bodyInfo.description,
+        isSse: bodyInfo.isSse,
+      });
+    }
+  } else if (returnType.kind === "Model") {
+    const model = returnType as Model;
+    if (model.name === "SSEStream") {
+      responses.push({
+        statusCode: 200,
+        bodyType: "axum::response::Response",
+        bodyDescription: "Server-Sent Events stream",
+        isSse: true,
+      });
+      return responses;
+    }
+    let statusCode = 200;
+    let bodyType: string | undefined;
+    let bodyDescription: string | undefined;
+    const isSse = false;
+
+    for (const [propName, prop] of model.properties) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const decorators = (prop as any).decorators;
+      let isBody = false;
+      if (decorators) {
+        for (const key of Object.keys(decorators)) {
+          const decorator = decorators[key];
+          const name = getDecoratorName(decorator);
+          if (name === "body" || name === "bodyRoot") {
+            isBody = true;
+            break;
+          }
+        }
+      }
+      if (isBody || propName === "body") {
+        const { type: rustType } = getRustTypeForProperty(
+          prop.type,
+          program,
+          anonymousEnums,
+        );
+        bodyType = rustType;
+        bodyDescription = getDoc(program, prop);
+      } else if (propName === "statusCode") {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const typeAny = prop.type as any;
+        if (typeAny.value !== undefined) {
+          statusCode = typeAny.value as number;
+        }
+      }
+    }
+    responses.push({
+      statusCode,
+      bodyType,
+      bodyDescription,
+      isSse,
+    });
+  }
+
+  return responses;
+}
+
+export function getStatusCode(variant: { type: Type }): number {
+  if (variant.type.kind === "Model") {
+    const model = variant.type as Model;
+    for (const [propName, prop] of model.properties) {
+      if (propName === "statusCode") {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const typeAny = prop.type as any;
+        if (typeAny.value !== undefined) {
+          return typeAny.value as number;
+        }
+      }
+    }
+  }
+  return 200;
+}
+
+export function getBodyFromResponse(
+  variant: { type: Type },
+  program: Program,
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): {
+  type: string | undefined;
+  description: string | undefined;
+  isSse?: boolean;
+} {
+  if (variant.type.kind === "Model") {
+    const model = variant.type as Model;
+    if (model.name === "SSEStream") {
+      return {
+        type: "axum::response::Response",
+        description: "Server-Sent Events stream",
+        isSse: true,
+      };
+    }
+    for (const [_propName, prop] of model.properties) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const decorators = (prop as any).decorators;
+      let isBody = false;
+      if (decorators) {
+        for (const key of Object.keys(decorators)) {
+          const decorator = decorators[key];
+          const name = getDecoratorName(decorator);
+          if (name === "body" || name === "bodyRoot") {
+            isBody = true;
+            break;
+          }
+        }
+      }
+      if (isBody) {
+        const { type: rustType } = getRustTypeForProperty(
+          prop.type,
+          program,
+          anonymousEnums,
+        );
+        return { type: rustType, description: getDoc(program, prop) };
+      }
+    }
+  }
+  return { type: undefined, description: undefined };
+}

package/src/parser/routes.ts

@@ -0,0 +1,47 @@
+import { Namespace, Operation, Program } from "@typespec/compiler";
+import { getDecoratorName, getDecoratorArgValue } from "./decorators.js";
+
+export function getRoute(
+  _program: Program,
+  target: Namespace | Operation,
+): string {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const decorators = (target as any).decorators;
+  if (!decorators) return "";
+
+  for (const key of Object.keys(decorators)) {
+    const decorator = decorators[key];
+    const name = getDecoratorName(decorator);
+    if (name === "route") {
+      return getDecoratorArgValue(decorator, 0);
+    }
+  }
+  return "";
+}
+
+export function getFullRoute(program: Program, ns: Namespace): string {
+  const routes: string[] = [];
+  let current: Namespace | undefined = ns;
+
+  while (current) {
+    const route = getRoute(program, current);
+    if (route) {
+      routes.unshift(route);
+    }
+    current = current.namespace;
+  }
+
+  return routes.join("");
+}
+
+export function buildFullPath(
+  namespaceRoute: string,
+  operationRoute: string,
+): string {
+  let fullPath = namespaceRoute + operationRoute;
+  fullPath = fullPath.replace(/\/+/g, "/");
+  if (fullPath.length > 1 && fullPath.endsWith("/")) {
+    fullPath = fullPath.slice(0, -1);
+  }
+  return fullPath;
+}

package/src/parser/types.ts

@@ -0,0 +1,215 @@
+import {
+  Enum,
+  getFormat,
+  getPattern,
+  IntrinsicType,
+  isArrayModelType,
+  isRecordModelType,
+  Model,
+  ModelProperty,
+  Namespace,
+  Program,
+  Scalar,
+  StringLiteral,
+  Type,
+  Union,
+} from "@typespec/compiler";
+import { formatToRust, scalarToRust } from "../formatter/mappings.js";
+import { toPascalCase } from "../formatter/strings.js";
+import { AnonymousStringLiteralUnion } from "../models/types.js";
+
+const typeSpecNamespaces = new Set([
+  "TypeSpec",
+  "@typespec/http",
+  "@typespec/rest",
+  "@typespec/openapi",
+  "@typespec/openapi3",
+  "@typespec/json-schema",
+]);
+
+export function isStdLibNamespace(ns: Namespace | undefined): boolean {
+  if (!ns) return false;
+  const fullName = ns.name;
+  if (typeSpecNamespaces.has(fullName)) return true;
+  if (ns.namespace) return isStdLibNamespace(ns.namespace);
+  return false;
+}
+
+export function isStdLibType(type: Type): boolean {
+  if ("namespace" in type) {
+    const ns = (type as Model | Enum | Union | Scalar).namespace;
+    if (isStdLibNamespace(ns as Namespace)) return true;
+  }
+  return false;
+}
+
+export function getRustTypeForProperty(
+  type: Type,
+  program: Program,
+  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
+): { type: string; isStringLiteral: boolean; stringLiteralValue?: string } {
+  const kind = type.kind as string;
+
+  if (kind === "Model") {
+    const model = type as Model;
+    if (isArrayModelType(model) && model.indexer?.value) {
+      const element = getRustTypeForProperty(
+        model.indexer.value,
+        program,
+        anonymousEnums,
+      );
+      return { type: `Vec<${element.type}>`, isStringLiteral: false };
+    }
+    if (isRecordModelType(model) && model.indexer?.value) {
+      const value = getRustTypeForProperty(
+        model.indexer.value,
+        program,
+        anonymousEnums,
+      );
+      return {
+        type: `std::collections::HashMap<String, ${value.type}>`,
+        isStringLiteral: false,
+      };
+    }
+    return { type: toPascalCase(model.name), isStringLiteral: false };
+  }
+
+  if (kind === "ModelProperty") {
+    return getRustTypeForProperty(
+      (type as ModelProperty).type,
+      program,
+      anonymousEnums,
+    );
+  }
+
+  if (kind === "Enum") {
+    return { type: toPascalCase((type as Enum).name), isStringLiteral: false };
+  }
+
+  if (kind === "Union") {
+    const unionType = type as Union;
+    const variants = Array.from(unionType.variants.values());
+    const allStringLiterals = variants.every((v) => v.type.kind === "String");
+
+    if (allStringLiterals) {
+      if (unionType.name) {
+        return {
+          type: toPascalCase(unionType.name),
+          isStringLiteral: false,
+        };
+      }
+      const values = variants.map((v) => (v.type as StringLiteral).value);
+      const sanitized = values.map((v) => v.replace(/_/g, ""));
+      const firstTwo = sanitized.slice(0, 2).map(toPascalCase).join("");
+      const enumName = `Enum${firstTwo}${sanitized.length}`;
+      if (!anonymousEnums.has(enumName)) {
+        anonymousEnums.set(enumName, {
+          enumName,
+          variants: variants.map((v) => v.type as StringLiteral),
+        });
+      }
+      return { type: enumName, isStringLiteral: false };
+    }
+
+    const nonNullVariants = variants.filter((v) => {
+      const vt = v.type;
+      if ((vt.kind as string) === "Null") return false;
+      if (
+        (vt.kind as string) === "Intrinsic" &&
+        (vt as IntrinsicType).name === "null"
+      )
+        return false;
+      return true;
+    });
+
+    if (
+      nonNullVariants.length === 1 &&
+      (variants.length === 2 ||
+        variants.some((v) => {
+          const vt = v.type;
+          return (
+            (vt.kind as string) === "Null" ||
+            ((vt.kind as string) === "Intrinsic" &&
+              (vt as IntrinsicType).name === "null")
+          );
+        }))
+    ) {
+      const vt = getRustTypeForProperty(
+        nonNullVariants[0].type,
+        program,
+        anonymousEnums,
+      );
+      return { type: `Option<${vt.type}>`, isStringLiteral: false };
+    }
+
+    const variantStrings: string[] = [];
+    for (const v of variants) {
+      const vt = v.type;
+      if ((vt.kind as string) === "Null") continue;
+      if (
+        (vt.kind as string) === "Intrinsic" &&
+        (vt as IntrinsicType).name === "null"
+      )
+        continue;
+      const rustVt = getRustTypeForProperty(vt, program, anonymousEnums);
+      variantStrings.push(rustVt.type);
+    }
+    const uniqueTypes = [...new Set(variantStrings)];
+    const resultType =
+      uniqueTypes.length === 1
+        ? uniqueTypes[0]
+        : `(${uniqueTypes.join(" | ")})`;
+    return { type: resultType, isStringLiteral: false };
+  }
+
+  if (kind === "Scalar") {
+    const scalar = type as Scalar;
+    const format = getFormat(program, scalar);
+    const pattern = getPattern(program, scalar);
+
+    if (format && formatToRust[format] && !pattern) {
+      return { type: formatToRust[format], isStringLiteral: false };
+    }
+    if (pattern) {
+      return { type: toPascalCase(scalar.name), isStringLiteral: false };
+    }
+    return {
+      type: scalarToRust[scalar.name] ?? scalar.name,
+      isStringLiteral: false,
+    };
+  }
+
+  if (kind === "Intrinsic") {
+    const intrinsic = type as IntrinsicType;
+    const format = getFormat(program, type);
+    if (format && formatToRust[format]) {
+      return { type: formatToRust[format], isStringLiteral: false };
+    }
+    return {
+      type: scalarToRust[intrinsic.name] ?? "serde_json::Value",
+      isStringLiteral: false,
+    };
+  }
+
+  if (kind === "String") {
+    return { type: "String", isStringLiteral: false };
+  }
+
+  if (kind === "StringLiteral") {
+    return {
+      type: "String",
+      isStringLiteral: true,
+      stringLiteralValue: (type as StringLiteral).value,
+    };
+  }
+
+  if (kind === "Boolean" || kind === "BooleanLiteral") {
+    return { type: "bool", isStringLiteral: false };
+  }
+
+  if (kind === "Number" || kind === "NumericLiteral") {
+    return { type: "f64", isStringLiteral: false };
+  }
+
+  return { type: "serde_json::Value", isStringLiteral: false };
+}