typespec-rust-emitter 0.11.0 → 0.13.0

package/dist/src/emitter.js

@@ -1,1254 +1,9 @@
-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");
-const rustSelfReceiverKey = Symbol("rustSelfReceiver");
-export function $rustDerive(context, target, derive) {
-    if (target.kind !== "Model" && target.kind !== "Enum") {
-        context.program.reportDiagnostic({
-            code: "rust-derive-invalid-target",
-            message: `@rustDerive can only be applied to models and enums`,
-            severity: "error",
-            target: context.decoratorTarget,
-        });
-        return;
-    }
-    const ns = target.kind === "Model"
-        ? target.namespace
-            ? getNamespaceFullName(target.namespace)
-            : ""
-        : target.namespace
-            ? getNamespaceFullName(target.namespace)
-            : "";
-    if (!ns.startsWith("TypeSpec")) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const info = target[rustDeriveKey];
-        if (info) {
-            if (!info.derives.includes(derive)) {
-                info.derives.push(derive);
-            }
-        }
-        else {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            target[rustDeriveKey] = { derives: [derive] };
-        }
-    }
-}
-export function $rustDerives(context, target, ...derives) {
-    for (const derive of derives) {
-        $rustDerive(context, target, derive);
-    }
-}
-export function $rustAttr(context, target, attr) {
-    if (target.kind !== "Model" &&
-        target.kind !== "Enum" &&
-        target.kind !== "ModelProperty") {
-        context.program.reportDiagnostic({
-            code: "rust-attr-invalid-target",
-            message: `@rustAttr can only be applied to models, enums, and model properties`,
-            severity: "error",
-            target: context.decoratorTarget,
-        });
-        return;
-    }
-    let ns;
-    if (target.kind === "Model") {
-        ns = target.namespace;
-    }
-    else if (target.kind === "Enum") {
-        ns = target.namespace;
-    }
-    else if (target.kind === "ModelProperty") {
-        ns = target.model?.namespace;
-    }
-    const nsFullName = ns ? getNamespaceFullName(ns) : "";
-    if (!nsFullName.startsWith("TypeSpec")) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const info = target[rustAttrKey];
-        if (info) {
-            if (!info.attrs.includes(attr)) {
-                info.attrs.push(attr);
-            }
-        }
-        else {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            target[rustAttrKey] = { attrs: [attr] };
-        }
-    }
-}
-export function $rustAttrs(context, target, ...attrs) {
-    for (const attr of 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 };
-    }
-}
-export function $rustMut(context, target) {
-    if (target.kind !== "Operation") {
-        context.program.reportDiagnostic({
-            code: "rust-mut-invalid-target",
-            message: `@rustMut can only be applied to operations`,
-            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[rustSelfReceiverKey] = "&mut self";
-    }
-}
-export function $rustOwn(context, target) {
-    if (target.kind !== "Operation") {
-        context.program.reportDiagnostic({
-            code: "rust-own-invalid-target",
-            message: `@rustOwn can only be applied to operations`,
-            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[rustSelfReceiverKey] = "self";
-    }
-}
-function getDecoratorName(decorator) {
-    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 "";
-}
-function getDecoratorArgValue(decorator, index = 0) {
-    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 "";
-}
-function getHttpMethod(_program, operation) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const decorators = operation.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;
-}
-function getRoute(_program, target) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const decorators = target.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 "";
-}
-function getFullRoute(program, ns) {
-    const routes = [];
-    let current = ns;
-    while (current) {
-        const route = getRoute(program, current);
-        if (route) {
-            routes.unshift(route);
-        }
-        current = current.namespace;
-    }
-    return routes.join("");
-}
-function hasAuthDecorator(operation) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const decorators = operation.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;
-}
-function getSelfReceiver(operation) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const receiver = operation[rustSelfReceiverKey];
-    return receiver ?? "&self";
-}
-function getOperationParameters(program, operation, anonymousEnums) {
-    const params = [];
-    const model = operation.parameters;
-    for (const [propName, prop] of model.properties) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const decorators = prop.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") {
-                    isBody = true;
-                    break;
-                }
-            }
-        }
-        if (isBody)
-            continue;
-        let location = "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;
-}
-function getOperationBody(operation) {
-    for (const [_propName, prop] of operation.parameters.properties) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const decorators = prop.decorators;
-        if (!decorators)
-            continue;
-        for (const key of Object.keys(decorators)) {
-            const decorator = decorators[key];
-            const name = getDecoratorName(decorator);
-            if (name === "body" || name === "bodyRoot") {
-                return prop;
-            }
-        }
-    }
-    return undefined;
-}
-function getOperationResponses(program, operation, anonymousEnums) {
-    const responses = [];
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const returnType = operation.returnType;
-    // 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;
-        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;
-        if (model.name === "SSEStream") {
-            responses.push({
-                statusCode: 200,
-                bodyType: "axum::response::Response",
-                bodyDescription: "Server-Sent Events stream",
-                isSse: true,
-            });
-            return responses;
-        }
-        let foundStatusCode = false;
-        for (const [propName, prop] of model.properties) {
-            if (propName === "body") {
-                const { type: rustType } = getRustTypeForProperty(prop.type, program, anonymousEnums);
-                responses.push({
-                    statusCode: 200,
-                    bodyType: rustType,
-                    bodyDescription: getDoc(program, prop),
-                });
-            }
-            else if (propName === "statusCode") {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const typeAny = prop.type;
-                if (typeAny.value !== undefined) {
-                    const statusCode = typeAny.value;
-                    responses.push({
-                        statusCode,
-                        bodyType: undefined,
-                        bodyDescription: undefined,
-                    });
-                    foundStatusCode = true;
-                }
-            }
-        }
-        if (!foundStatusCode && responses.length === 0) {
-            responses.push({
-                statusCode: 200,
-                bodyType: undefined,
-                bodyDescription: undefined,
-            });
-        }
-    }
-    return responses;
-}
-function getStatusCode(variant) {
-    if (variant.type.kind === "Model") {
-        const model = variant.type;
-        for (const [propName, prop] of model.properties) {
-            if (propName === "statusCode") {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const typeAny = prop.type;
-                if (typeAny.value !== undefined) {
-                    return typeAny.value;
-                }
-            }
-        }
-    }
-    return 200;
-}
-function getBodyFromResponse(variant, program, anonymousEnums) {
-    if (variant.type.kind === "Model") {
-        const model = variant.type;
-        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.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 };
-}
-function getAllOperations(program) {
-    const seenNamespaces = new Set();
-    const namespaceOps = new Map();
-    navigateProgram(program, {
-        namespace(ns) {
-            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) {
-            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 = [];
-    for (const [, entry] of namespaceOps) {
-        if (entry.ops.length > 0) {
-            result.push({ namespace: entry.ns, operations: entry.ops });
-        }
-    }
-    return result;
-}
-function buildFullPath(namespaceRoute, operationRoute) {
-    let fullPath = namespaceRoute + operationRoute;
-    fullPath = fullPath.replace(/\/+/g, "/");
-    if (fullPath.length > 1 && fullPath.endsWith("/")) {
-        fullPath = fullPath.slice(0, -1);
-    }
-    return fullPath;
-}
-function emitOperationInfo(program, op, nsRoute, anonymousEnums) {
-    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, "_");
-    return {
-        name: opName,
-        method,
-        path: fullPath,
-        tags,
-        parameters: params,
-        body: body,
-        responses,
-        doc,
-    };
-}
-function getStatusVariantName(statusCode) {
-    const statusNames = {
-        200: "Ok",
-        201: "Created",
-        202: "Accepted",
-        204: "NoContent",
-        400: "BadRequest",
-        401: "Unauthorized",
-        403: "Forbidden",
-        404: "NotFound",
-        409: "Conflict",
-        500: "InternalServerError",
-    };
-    return statusNames[statusCode] || `Status${statusCode}`;
-}
-function getHttpStatusCode(statusCode) {
-    const statusCodes = {
-        200: "StatusCode::OK",
-        201: "StatusCode::CREATED",
-        202: "StatusCode::ACCEPTED",
-        204: "StatusCode::NO_CONTENT",
-        400: "StatusCode::BAD_REQUEST",
-        401: "StatusCode::UNAUTHORIZED",
-        403: "StatusCode::FORBIDDEN",
-        404: "StatusCode::NOT_FOUND",
-        409: "StatusCode::CONFLICT",
-        500: "StatusCode::INTERNAL_SERVER_ERROR",
-    };
-    return statusCodes[statusCode] || `StatusCode::from_u16(${statusCode})`;
-}
-function generateServerTrait(program, namespaceGroups, anonymousEnums) {
-    const parts = [];
-    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;
-
-#[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 = [];
-            // 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) {
-                const bodyType = getRustTypeForProperty(opInfo.body.type, program, anonymousEnums);
-                paramParts.push(`body: ${bodyType.type}`);
-            }
-            const paramsStr = paramParts.join(", ");
-            const selfReceiver = getSelfReceiver(op);
-            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");
-}
-function generateResponseEnums(program, namespaceGroups, anonymousEnums) {
-    const parts = [];
-    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.responses.length === 0)
-                continue;
-            const responseName = `${nsName}${toPascalCase(opInfo.name)}Response`;
-            const variants = [];
-            for (const resp of opInfo.responses) {
-                const variantName = getStatusVariantName(resp.statusCode);
-                if (!resp.bodyType) {
-                    variants.push(`    ${variantName},`);
-                }
-                else if (resp.isSse) {
-                    variants.push(`    ${variantName}(${resp.bodyType}),`);
-                }
-                else {
-                    variants.push(`    ${variantName}(Json<${resp.bodyType}>),`);
-                }
-            }
-            parts.push(`#[allow(clippy::type_complexity)]
-pub enum ${responseName} {
-${variants.join("\n")}
-}
-`);
-            parts.push(`impl IntoResponse for ${responseName} {
-    fn into_response(self) -> axum::response::Response {
-        match self {
-`);
-            for (const resp of opInfo.responses) {
-                const variantName = getStatusVariantName(resp.statusCode);
-                const statusCodeStr = getHttpStatusCode(resp.statusCode);
-                if (!resp.bodyType) {
-                    parts.push(`            ${responseName}::${variantName} => ${statusCodeStr}.into_response(),`);
-                }
-                else if (resp.isSse) {
-                    parts.push(`            ${responseName}::${variantName}(body) => body.into_response(),`);
-                }
-                else {
-                    parts.push(`            ${responseName}::${variantName}(body) => (${statusCodeStr}, body).into_response(),`);
-                }
-            }
-            parts.push(`        }
-    }
-}
-`);
-        }
-    }
-    return parts.join("\n");
-}
-function generateRouter(program, namespaceGroups, anonymousEnums) {
-    const handlers = [];
-    const queryTypeStructs = [];
-    const publicRoutes = [];
-    const protectedRoutes = [];
-    const usedMethods = new Set();
-    for (const group of namespaceGroups) {
-        const nsRoute = getFullRoute(program, group.namespace);
-        if (!nsRoute)
-            continue;
-        const nsName = toPascalCase(group.namespace.name.replace(/[^a-zA-Z0-9_]/g, "_"));
-        for (const op of group.operations) {
-            const opInfo = emitOperationInfo(program, op, nsRoute, anonymousEnums);
-            if (!opInfo)
-                continue;
-            const method = opInfo.method.toLowerCase();
-            usedMethods.add(method);
-            const handlerFnName = toRustIdent(`${nsName}_${opInfo.name}`);
-            const traitFnName = handlerFnName;
-            const isProtected = hasAuthDecorator(op);
-            const selfReceiver = getSelfReceiver(op);
-            const pathParams = opInfo.parameters.filter((p) => p.location === "path");
-            const hasPathParams = pathParams.length > 0;
-            const queryParams = opInfo.parameters.filter((p) => p.location === "query");
-            const hasQueryParams = queryParams.length > 0;
-            const hasBody = !!opInfo.body;
-            // Build extractor lines and server method call arguments
-            // IMPORTANT: axum requires specific extractor order:
-            // State -> Extension -> Path -> Query -> Json -> Body
-            const extractorLines = [];
-            const serverArgs = [];
-            // State is always first (added in handler template)
-            const serviceBinding = selfReceiver === "&mut self" ? "mut service" : "service";
-            // Extension (claims) comes after State
-            if (isProtected) {
-                extractorLines.push(`    Extension(claims): Extension<S::Claims>,`);
-                serverArgs.push(`claims`);
-            }
-            // Path params come after Extension
-            if (hasPathParams) {
-                const pathTypes = pathParams.map((p) => p.rustType).join(", ");
-                const pathFields = pathParams.map((p) => p.rustName).join(", ");
-                if (pathParams.length === 1) {
-                    extractorLines.push(`    Path(${pathFields}): Path<${pathTypes}>,`);
-                }
-                else {
-                    extractorLines.push(`    Path((${pathFields})): Path<(${pathTypes})>,`);
-                }
-                // Add path params to server method args
-                for (const param of pathParams) {
-                    serverArgs.push(param.rustName);
-                }
-            }
-            // Query params come after Path
-            if (hasQueryParams && queryParams.length > 0) {
-                const queryTypeName = `${toPascalCase(handlerFnName)}Query`;
-                const queryFields = queryParams
-                    .map((p) => `    #[serde(rename = "${p.name}")]\n    pub ${p.rustName}: ${p.rustType}`)
-                    .join(",\n");
-                queryTypeStructs.push(`#[derive(Debug, Clone, serde::Deserialize)]\npub struct ${queryTypeName} {\n${queryFields}\n}`);
-                extractorLines.push(`    Query(params): Query<${queryTypeName}>,`);
-                for (const param of queryParams) {
-                    serverArgs.push(`params.${param.rustName}`);
-                }
-            }
-            // Json body comes last
-            if (hasBody && opInfo.body) {
-                const bodyType = getRustTypeForProperty(opInfo.body.type, program, anonymousEnums);
-                extractorLines.push(`    Json(payload): Json<${bodyType.type}>,`);
-                serverArgs.push(`payload`);
-            }
-            // Build server method call
-            const serverArgsStr = serverArgs.join(", ");
-            const serverCall = `service.${traitFnName}(${serverArgsStr}).await`;
-            // All handlers use <S> generics, Claims is now an associated type
-            // For &mut self, we need Clone because service is extracted multiple times
-            // For self, we can't use Clone (would need Arc/Mutex or different pattern)
-            const needsClone = selfReceiver !== "self" ? "+ Clone" : "";
-            const handlerCode = selfReceiver === "self"
-                ? `// NOTE: ${handlerFnName} takes self and cannot be used with the router pattern.
-// It consumes the service, so you need to implement your own handler pattern.
-pub async fn ${handlerFnName}_handler<S>(
-    axum::extract::State(service): axum::extract::State<S>,
-${extractorLines.join("\n")}
-) -> impl axum::response::IntoResponse
-where
-    S: Server + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = service.${traitFnName}(${serverArgsStr}).await;
-    match result {
-        Ok(response) => response.into_response(),
-        Err(e) => (
-            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
-            format!("Internal error: {e}"),
-        )
-            .into_response(),
-    }
-}`
-                : `pub async fn ${handlerFnName}_handler<S>(
-    axum::extract::State(${serviceBinding}): axum::extract::State<S>,
-${extractorLines.join("\n")}
-) -> impl axum::response::IntoResponse
-where
-    S: Server${needsClone} + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = ${serverCall};
-    match result {
-        Ok(response) => response.into_response(),
-        Err(e) => (
-            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
-            format!("Internal error: {e}"),
-        )
-            .into_response(),
-    }
-}`;
-            handlers.push(handlerCode);
-            // Don't add routes for self methods (they consume the service)
-            if (selfReceiver === "self") {
-                continue;
-            }
-            const routePath = `"${opInfo.path}"`;
-            let routeStmt = "";
-            if (isProtected) {
-                routeStmt = `.route(${routePath}, ${method}(${handlerFnName}_handler::<S>))`;
-                protectedRoutes.push(routeStmt);
-            }
-            else {
-                routeStmt = `.route(${routePath}, ${method}(${handlerFnName}_handler::<S>))`;
-                publicRoutes.push(routeStmt);
-            }
-        }
-    }
-    const methodImports = Array.from(usedMethods).sort().join(", ");
-    const routerBody = buildRouterBody(publicRoutes, protectedRoutes);
-    const parts = [];
-    parts.push(`use axum::extract::Query;
-use axum::routing::{${methodImports}};
-use axum::Router;
-
-`);
-    if (queryTypeStructs.length > 0) {
-        parts.push(queryTypeStructs.join("\n\n"));
-        parts.push("\n\n");
-    }
-    parts.push(handlers.join("\n\n"));
-    parts.push(`
-pub fn create_router<S, M>(service: S, middleware: M) -> Router
-where
-    S: Server + Clone + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-    M: FnOnce(Router<S>) -> Router<S> + Clone + Send + Sync + 'static,
-{
-${routerBody}
-}`);
-    return parts.join("\n");
-}
-function buildRouterBody(publicRoutes, protectedRoutes) {
-    const lines = [];
-    lines.push("    let mut router = Router::new();");
-    if (publicRoutes.length > 0) {
-        lines.push("    let public = Router::new()");
-        for (const r of publicRoutes) {
-            lines.push(`        ${r.trim()}`);
-        }
-        lines.push("        ;");
-        lines.push("    router = router.merge(public);");
-    }
-    if (protectedRoutes.length > 0) {
-        lines.push("    let protected = Router::new()");
-        for (const r of protectedRoutes) {
-            lines.push(`        ${r.trim()}`);
-        }
-        lines.push("        ;");
-        lines.push("    router = router.merge(middleware(protected));");
-    }
-    lines.push("    router.with_state(service)");
-    return lines.join("\n");
-}
-const scalarToRust = {
-    string: "String",
-    int8: "i8",
-    int16: "i16",
-    int32: "i32",
-    int64: "i64",
-    uint8: "u8",
-    uint16: "u16",
-    uint32: "u32",
-    uint64: "u64",
-    float32: "f32",
-    float64: "f64",
-    boolean: "bool",
-    bytes: "Vec<u8>",
-    plainDate: "chrono::NaiveDate",
-    plainTime: "chrono::NaiveTime",
-    utcDateTime: "chrono::DateTime<chrono::Utc>",
-    offsetDateTime: "chrono::DateTime<chrono::FixedOffset>",
-    plainDateTime: "chrono::NaiveDateTime",
-    duration: "String",
-    numeric: "f64",
-    integer: "i64",
-    float: "f64",
-    safeint: "i64",
-    decimal: "f64",
-    decimal128: "f64",
-    url: "String",
-};
-const formatToRust = {
-    uuid: "uuid::Uuid",
-    date: "chrono::NaiveDate",
-    time: "chrono::NaiveTime",
-    dateTime: "chrono::DateTime<chrono::Utc>",
-    "date-time": "chrono::DateTime<chrono::Utc>",
-};
-const typeSpecNamespaces = new Set([
-    "TypeSpec",
-    "@typespec/http",
-    "@typespec/rest",
-    "@typespec/openapi",
-    "@typespec/openapi3",
-    "@typespec/json-schema",
-]);
-function isStdLibNamespace(ns) {
-    if (!ns)
-        return false;
-    const fullName = ns.name;
-    if (typeSpecNamespaces.has(fullName))
-        return true;
-    if (ns.namespace)
-        return isStdLibNamespace(ns.namespace);
-    return false;
-}
-function isStdLibType(type) {
-    if ("namespace" in type) {
-        const ns = type.namespace;
-        if (isStdLibNamespace(ns))
-            return true;
-    }
-    return false;
-}
-function getRustTypeForProperty(type, program, anonymousEnums) {
-    const kind = type.kind;
-    if (kind === "Model") {
-        const model = type;
-        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.type, program, anonymousEnums);
-    }
-    if (kind === "Enum") {
-        return { type: toPascalCase(type.name), isStringLiteral: false };
-    }
-    if (kind === "Union") {
-        const unionType = type;
-        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.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),
-                });
-            }
-            return { type: enumName, isStringLiteral: false };
-        }
-        const nonNullVariants = variants.filter((v) => {
-            const vt = v.type;
-            if (vt.kind === "Null")
-                return false;
-            if (vt.kind === "Intrinsic" &&
-                vt.name === "null")
-                return false;
-            return true;
-        });
-        if (nonNullVariants.length === 1 &&
-            (variants.length === 2 ||
-                variants.some((v) => {
-                    const vt = v.type;
-                    return (vt.kind === "Null" ||
-                        (vt.kind === "Intrinsic" &&
-                            vt.name === "null"));
-                }))) {
-            const vt = getRustTypeForProperty(nonNullVariants[0].type, program, anonymousEnums);
-            return { type: `Option<${vt.type}>`, isStringLiteral: false };
-        }
-        const variantStrings = [];
-        for (const v of variants) {
-            const vt = v.type;
-            if (vt.kind === "Null")
-                continue;
-            if (vt.kind === "Intrinsic" &&
-                vt.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;
-        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;
-        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.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 };
-}
-function toRustIdent(name) {
-    const snakeCase = name.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
-    const result = snakeCase.replace(/[^a-z0-9_]/g, "_");
-    if (/^[0-9]/.test(result)) {
-        return "_" + result;
-    }
-    return result;
-}
-function toPascalCase(name) {
-    if (/^[^a-z]+$/.test(name)) {
-        return name;
-    }
-    if (/[-_]/.test(name)) {
-        return name
-            .split(/[-_]/)
-            .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
-            .join("");
-    }
-    return name.charAt(0).toUpperCase() + name.slice(1);
-}
-function toRustVariantName(name) {
-    return toPascalCase(name);
-}
-function formatDoc(doc) {
-    if (!doc)
-        return "";
-    return doc
-        .split("\n")
-        .map((line) => `/// ${line.trim()}`)
-        .join("\n");
-}
-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, 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;
-        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");
-}
-function emitModel(model, program, anonymousEnums) {
-    const parts = [];
-    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[rustDeriveKey];
-    if (customDerives) {
-        deriveAttrs.push(...customDerives.derives);
-    }
-    parts.push(`#[derive(${deriveAttrs.join(", ")})]`);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const customAttrs = model[rustAttrKey];
-    if (customAttrs) {
-        for (const attr of customAttrs.attrs) {
-            parts.push(`#[${attr}]`);
-        }
-    }
-    if (allProps.size > 0) {
-        const fields = [];
-        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[rustAttrKey];
-            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[rustImplKey];
-    if (customImpl) {
-        parts.push(`
-${customImpl.impl}`);
-    }
-    return parts.join("\n");
-}
-function getAllProperties(model, _program) {
-    const props = new Map();
-    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;
-}
-function emitEnum(enumType) {
-    const parts = [];
-    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[rustDeriveKey];
-    const allDerives = [...baseDerives];
-    if (customDerives) {
-        allDerives.push(...customDerives.derives);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const customAttrs = enumType[rustAttrKey];
-    const attrLines = [];
-    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");
-}
-function emitUnion(union, program) {
-    const parts = [];
-    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");
-}
-function emitScalar(scalar, program) {
-    const format = getFormat(program, scalar);
-    const pattern = getPattern(program, scalar);
-    const structName = toPascalCase(scalar.name);
-    const impls = [];
-    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: [],
-    };
-}
+import { emitFile, resolvePath, navigateProgram, } from "@typespec/compiler";
+import { isStdLibType, getAllOperations } from "./parser/index.js";
+import { emitModel, emitEnum, emitUnion, emitScalar, emitStringLiteralUnion, } from "./generator/types_file.js";
+import { generateServerTrait } from "./generator/server_trait.js";
+import { generateResponseEnums } from "./generator/response_enums.js";
+import { generateRouter } from "./generator/router.js";
 export async function $onEmit(context, _options) {
     const content = [];
     const models = [];
@@ -1306,7 +61,7 @@ export async function $onEmit(context, _options) {
         parts.push(`#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\n#[allow(clippy::enum_variant_names)]\npub enum ${enumName} {`);
         for (let i = 0; i < anonEnum.variants.length; i++) {
             const literal = anonEnum.variants[i];
-            const variantName = toPascalCase(literal.value);
+            const variantName = (literal.value.charAt(0).toUpperCase() + literal.value.slice(1)).replace(/[^a-zA-Z0-9]/g, "");
             if (i === 0) {
                 parts.push(`  #[default]`);
             }