typespec-rust-emitter 0.1.0 → 0.2.0

package/dist/src/emitter.js

@@ -1,4 +1,4 @@
-import { emitFile, resolvePath, navigateProgram, getDoc, isArrayModelType, isRecordModelType, getFormat, getPattern, isErrorModel, getNamespaceFullName, } from "@typespec/compiler";
+import { emitFile, resolvePath, navigateProgram, getDoc, isArrayModelType, isRecordModelType, getFormat, getPattern, isErrorModel, getNamespaceFullName, getTags, } from "@typespec/compiler";
 const rustDeriveKey = Symbol("rustDerive");
 export function $rustDerive(context, target, derive) {
     if (target.kind !== "Model") {
@@ -29,6 +29,557 @@ export function $rustDerives(context, target, ...derives) {
         $rustDerive(context, target, derive);
     }
 }
+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) {
+    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) {
+    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 hasAuthDecorator(operation) {
+    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 getOperationParameters(program, operation, anonymousEnums) {
+    const params = [];
+    const model = operation.parameters;
+    for (const [propName, prop] of model.properties) {
+        const decorators = prop.decorators;
+        let location = "query";
+        let rustName = toRustIdent(propName);
+        if (decorators) {
+            if (decorators["$path"]) {
+                location = "path";
+            }
+            else if (decorators["$query"]) {
+                location = "query";
+            }
+            else if (decorators["$header"]) {
+                location = "header";
+                const headerDec = decorators["$header"];
+                if (headerDec?.value) {
+                    rustName = headerDec.value;
+                }
+            }
+            else if (decorators["$cookie"]) {
+                location = "cookie";
+            }
+        }
+        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) {
+        const decorators = prop.decorators;
+        if (decorators?.["$body"] || decorators?.["$bodyRoot"]) {
+            return prop;
+        }
+    }
+    return undefined;
+}
+function getOperationResponses(program, operation, anonymousEnums) {
+    const responses = [];
+    const returnType = operation.returnType;
+    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,
+            });
+        }
+    }
+    else if (returnType.kind === "Model") {
+        const model = returnType;
+        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),
+                });
+            }
+        }
+    }
+    return responses;
+}
+function getStatusCode(variant) {
+    if (variant.type.kind === "Model") {
+        const model = variant.type;
+        for (const [propName, prop] of model.properties) {
+            if (propName === "statusCode") {
+                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;
+        for (const [propName, prop] of model.properties) {
+            if (propName === "body") {
+                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;
+            if (!seenNamespaces.has(ns.name)) {
+                seenNamespaces.add(ns.name);
+                namespaceOps.set(ns.name, { ns, ops: [] });
+            }
+        },
+        operation(op) {
+            const method = getHttpMethod(program, op);
+            if (!method)
+                return;
+            const ns = op.namespace;
+            if (!ns)
+                return;
+            if (!seenNamespaces.has(ns.name)) {
+                seenNamespaces.add(ns.name);
+                namespaceOps.set(ns.name, { ns, ops: [] });
+            }
+            const entry = namespaceOps.get(ns.name);
+            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::{http::StatusCode, 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 requestName = `${nsName}${toPascalCase(opInfo.name)}Request`;
+            const responseName = `${nsName}${toPascalCase(opInfo.name)}Response`;
+            const fnName = toRustIdent(`${nsName}_${opInfo.name}`);
+            const isProtected = hasAuthDecorator(op);
+            if (isProtected) {
+                parts.push(`    async fn ${fnName}(&self, claims: Self::Claims, request: ${requestName}) -> Result<${responseName}>;`);
+            }
+            else {
+                parts.push(`    async fn ${fnName}(&self, request: ${requestName}) -> Result<${responseName}>;`);
+            }
+        }
+    }
+    parts.push("}");
+    return parts.join("\n");
+}
+function generateRequestStructs(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;
+            const params = opInfo.parameters;
+            const requestName = `${nsName}${toPascalCase(opInfo.name)}Request`;
+            const fields = [];
+            for (const param of params) {
+                const rustType = param.optional
+                    ? `Option<${param.rustType}>`
+                    : param.rustType;
+                fields.push(`  #[serde(rename = "${param.name}", flatten)]`);
+                fields.push(`  pub ${param.rustName}: ${rustType},`);
+            }
+            if (opInfo.body) {
+                const bodyType = getRustTypeForProperty(opInfo.body.type, program, anonymousEnums);
+                fields.push(`  #[serde(rename = "body")]`);
+                fields.push(`  pub body: ${bodyType.type},`);
+            }
+            parts.push(`#[derive(Debug, Clone, serde::Deserialize)]
+pub struct ${requestName} {
+${fields.join("\n")}
+}
+`);
+        }
+    }
+    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 {
+                    variants.push(`    ${variantName}(Json<${resp.bodyType}>),`);
+                }
+            }
+            parts.push(`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 {
+                    parts.push(`            ${responseName}::${variantName}(body) => (${statusCodeStr}, body).into_response(),`);
+                }
+            }
+            parts.push(`        }
+    }
+}
+`);
+        }
+    }
+    return parts.join("\n");
+}
+function generateRouter(program, namespaceGroups, anonymousEnums) {
+    const handlers = [];
+    const publicRoutes = [];
+    const protectedRoutes = [];
+    const usedMethods = new Set();
+    for (const group of namespaceGroups) {
+        const nsRoute = getRoute(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 requestName = `${nsName}${toPascalCase(opInfo.name)}Request`;
+            const isProtected = hasAuthDecorator(op);
+            const pathParams = opInfo.parameters.filter((p) => p.location === "path");
+            const queryParams = opInfo.parameters.filter((p) => p.location === "query");
+            const hasPathParams = pathParams.length > 0;
+            const hasQueryParams = queryParams.length > 0;
+            const hasBody = !!opInfo.body;
+            // Build extractor lines and request construction expression
+            const extractorLines = [];
+            let requestExpr = "";
+            if (hasPathParams) {
+                const pathTypes = pathParams.map((p) => p.rustType).join(", ");
+                const pathFields = pathParams.map((p) => p.rustName).join(", ");
+                if (pathParams.length === 1) {
+                    extractorLines.push(`    axum::extract::Path(${pathFields}): axum::extract::Path<${pathTypes}>,`);
+                }
+                else {
+                    extractorLines.push(`    axum::extract::Path((${pathFields})): axum::extract::Path<(${pathTypes})>,`);
+                }
+            }
+            if (hasQueryParams) {
+                extractorLines.push(`    axum::extract::Query(query): axum::extract::Query<${requestName}>,`);
+            }
+            else if (hasBody) {
+                extractorLines.push(`    axum::Json(body): axum::Json<${requestName}Body>,`);
+            }
+            if (isProtected) {
+                extractorLines.push(`    axum::Extension(claims): axum::Extension<S::Claims>,`);
+            }
+            // Build request struct expression
+            if (hasOnlyPathParams(hasPathParams, hasQueryParams, hasBody)) {
+                const pathAssignments = pathParams
+                    .map((p) => `${p.rustName},`)
+                    .join(" ");
+                requestExpr = `${requestName} { ${pathAssignments} }`;
+            }
+            else if (hasQueryParams) {
+                if (hasPathParams) {
+                    const pathAssignments = pathParams
+                        .map((p) => `${p.rustName},`)
+                        .join(" ");
+                    requestExpr = `${requestName} { ${pathAssignments} ..query }`;
+                }
+                else {
+                    requestExpr = "query";
+                }
+            }
+            else if (hasBody) {
+                if (hasPathParams) {
+                    const pathAssignments = pathParams
+                        .map((p) => `${p.rustName},`)
+                        .join(" ");
+                    requestExpr = `${requestName} { ${pathAssignments} body }`;
+                }
+                else {
+                    requestExpr = `${requestName} { body }`;
+                }
+            }
+            else {
+                requestExpr = `${requestName} {}`;
+            }
+            // Server method call
+            const serverCall = isProtected
+                ? `service.${traitFnName}(claims, ${requestExpr}).await`
+                : `service.${traitFnName}(${requestExpr}).await`;
+            // All handlers use <S> generics, Claims is now an associated type
+            let handlerCode = `pub async fn ${handlerFnName}_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+${extractorLines.join("\n")}
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + 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);
+            let 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::response::IntoResponse;
+use axum::routing::{${methodImports}};
+use axum::Router;
+
+`);
+    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 hasOnlyPathParams(hasPath, hasQuery, hasBody) {
+    return hasPath && !hasQuery && !hasBody;
+}
+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",
@@ -284,9 +835,8 @@ function emitModel(model, program, anonymousEnums) {
     if (isError && allProps.size > 0) {
         parts.push('#[error("{code}: {message}")]');
     }
-    parts.push(`pub struct ${name}`);
     if (allProps.size > 0) {
-        parts.push(" {");
+        const fields = [];
         for (const [propName, prop] of allProps) {
             const doc = getDoc(program, prop);
             const { type: rustType } = getRustTypeForProperty(prop.type, program, anonymousEnums);
@@ -294,19 +844,22 @@ function emitModel(model, program, anonymousEnums) {
             const fieldName = toRustIdent(propName);
             const serdeRename = propName !== fieldName ? `#[serde(rename = "${propName}")]` : "";
             if (doc) {
-                parts.push(`\n  ${formatDoc(doc)}`);
+                fields.push(`  ${formatDoc(doc)}`);
             }
             if (serdeRename) {
-                parts.push(`  ${serdeRename}`);
+                fields.push(`  ${serdeRename}`);
             }
             if (optional) {
-                parts.push(`  #[serde(skip_serializing_if = "Option::is_none")]`);
+                fields.push(`  #[serde(skip_serializing_if = "Option::is_none")]`);
             }
-            parts.push(`  pub ${fieldName}: ${optional ? `Option<${rustType}>` : rustType},`);
+            fields.push(`  pub ${fieldName}: ${optional ? `Option<${rustType}>` : rustType},`);
         }
-        parts.push("}");
+        parts.push(`pub struct ${name} {
+${fields.join("\n")}
+}`);
     }
     else {
+        parts.push(`pub struct ${name}`);
         parts.push("(());");
     }
     return parts.join("\n");
@@ -481,10 +1034,27 @@ export async function $onEmit(context, _options) {
         }
         content.push("");
     }
+    const namespaceGroups = getAllOperations(context.program);
     const outputContent = content.join("\n");
     await emitFile(context.program, {
         path: resolvePath(context.emitterOutputDir, "types.rs"),
         content: outputContent,
     });
+    if (namespaceGroups.length > 0) {
+        const serverTrait = generateServerTrait(context.program, namespaceGroups, anonymousEnums);
+        const requestStructs = generateRequestStructs(context.program, namespaceGroups, anonymousEnums);
+        const responseEnums = generateResponseEnums(context.program, namespaceGroups, anonymousEnums);
+        const router = generateRouter(context.program, namespaceGroups, anonymousEnums);
+        const serverContent = [
+            serverTrait,
+            requestStructs,
+            responseEnums,
+            router,
+        ].join("\n");
+        await emitFile(context.program, {
+            path: resolvePath(context.emitterOutputDir, "server.rs"),
+            content: serverContent,
+        });
+    }
 }
 //# sourceMappingURL=emitter.js.map