trpc-gen-python 0.1.0

package/README.md

@@ -0,0 +1,84 @@
+# trpc-gen-python
+
+Generate type-safe Python clients from tRPC routers. Automatically converts your tRPC endpoints into Pydantic models and httpx-based client code.
+
+## Installation
+
+```bash
+npx trpc-gen-python generate
+```
+
+Or install globally:
+
+```bash
+npm install -g trpc-gen-python
+trpc-gen-python generate
+```
+
+## Quick Start
+
+1. Create a `trpc-gen-python.toml` configuration file in your project root:
+
+```toml
+# Which endpoints to generate (supports glob patterns)
+endpoints = ["user.*", "post.list"]
+
+[router]
+# Path to your tRPC router file
+path = "./src/server/router.ts"
+# Export name of your router
+export = "appRouter"
+# Base URL for your tRPC API
+base_url = "http://localhost:3000/api/trpc"
+
+[output]
+# Output directory for generated Python code
+dir = "./generated"
+# Name of the generated Python package
+package_name = "trpc_client"
+```
+
+2. Run the generator:
+
+```bash
+npx trpc-gen-python generate
+```
+
+3. Use the generated Python client:
+
+```python
+from generated.trpc_client import TRPCClient
+
+client = TRPCClient()
+
+# Call your tRPC procedures
+user = client.user.get(id=123)
+posts = client.post.list(limit=10)
+```
+
+## CLI Options
+
+```bash
+trpc-gen-python generate [options]
+
+Options:
+  -c, --config <path>  Path to config file (default: trpc-gen-python.toml)
+  -h, --help          Display help
+  -V, --version       Display version
+```
+
+
+## Python Dependencies
+
+The generated client requires:
+```bash
+pip install pydantic httpx
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Issues and pull requests welcome!

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { loadConfig } from "./config.js";
+import { introspectRouter } from "./introspect.js";
+import { generatePythonClient } from "./codegen.js";
+const program = new Command();
+program
+    .name("trpc-gen-python")
+    .description("Generate Python clients from tRPC routers")
+    .version("0.1.0");
+program
+    .command("generate")
+    .description("Generate Python Pydantic models and httpx client from a tRPC router")
+    .option("-c, --config <path>", "Path to config file (default: trpc-gen-python.toml)")
+    .action(async (opts) => {
+    try {
+        console.log("Loading config...");
+        const config = loadConfig(opts.config);
+        console.log(`Introspecting router at ${config.router.path}...`);
+        const procedures = await introspectRouter(config);
+        console.log(`Found ${procedures.length} procedure(s), generating Python client...`);
+        generatePythonClient(config, procedures);
+        console.log("Done!");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Error: ${message}`);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/codegen.d.ts

@@ -0,0 +1,5 @@
+import type { Config, ProcedureInfo } from "./types.js";
+/**
+ * Main codegen function — writes the generated Python package to disk.
+ */
+export declare function generatePythonClient(config: Config, procedures: ProcedureInfo[]): void;

package/dist/codegen.js

@@ -0,0 +1,340 @@
+import { mkdirSync, writeFileSync } from "fs";
+import { resolve, join } from "path";
+/**
+ * Convert a tRPC procedure name like "user.getById" to a PascalCase class name
+ * like "UserGetById"
+ */
+function toPascalCase(procedureName) {
+    return procedureName
+        .split(".")
+        .map((segment) => segment
+        .split(/[-_]/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(""))
+        .join("");
+}
+/**
+ * Convert a tRPC procedure name like "user.getById" to a snake_case method name
+ * like "user_get_by_id"
+ */
+function toSnakeCase(procedureName) {
+    return procedureName
+        .split(".")
+        .map((segment) => segment
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        .replace(/[-]/g, "_")
+        .toLowerCase())
+        .join("_");
+}
+/**
+ * Map a JSON Schema type to a Python type string.
+ */
+function jsonSchemaTypeToPython(schema, modelPrefix, models) {
+    if (schema.anyOf) {
+        const types = schema.anyOf.map((s) => jsonSchemaTypeToPython(s, modelPrefix, models));
+        // If one of the types is None, it's Optional
+        const nonNone = types.filter((t) => t !== "None");
+        const hasNone = types.some((t) => t === "None");
+        if (hasNone && nonNone.length === 1) {
+            return `Optional[${nonNone[0]}]`;
+        }
+        return `Union[${types.join(", ")}]`;
+    }
+    if (schema.enum) {
+        // Generate a string literal union — for simplicity, use str
+        return "str";
+    }
+    const type = schema.type;
+    if (type === "string")
+        return "str";
+    if (type === "number")
+        return "float";
+    if (type === "integer")
+        return "int";
+    if (type === "boolean")
+        return "bool";
+    if (type === "null")
+        return "None";
+    if (type === "array") {
+        if (schema.items) {
+            const itemType = jsonSchemaTypeToPython(schema.items, modelPrefix, models);
+            return `List[${itemType}]`;
+        }
+        return "List[Any]";
+    }
+    if (type === "object") {
+        if (schema.properties) {
+            // Generate a nested model
+            const nestedName = modelPrefix;
+            const nestedCode = generateModelClass(nestedName, schema, models);
+            models.push({ name: nestedName, code: nestedCode });
+            return nestedName;
+        }
+        return "Dict[str, Any]";
+    }
+    return "Any";
+}
+/**
+ * Generate a Pydantic model class from a JSON Schema object.
+ */
+function generateModelClass(className, schema, models) {
+    const lines = [];
+    lines.push(`class ${className}(BaseModel):`);
+    const properties = schema.properties;
+    if (!properties || Object.keys(properties).length === 0) {
+        lines.push("    pass");
+        return lines.join("\n");
+    }
+    const required = new Set(schema.required || []);
+    for (const [propName, propSchema] of Object.entries(properties)) {
+        const nestedPrefix = `${className}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
+        let pyType = jsonSchemaTypeToPython(propSchema, nestedPrefix, models);
+        const isRequired = required.has(propName);
+        if (!isRequired && !pyType.startsWith("Optional[")) {
+            pyType = `Optional[${pyType}]`;
+        }
+        const safeName = pythonSafeName(propName);
+        const alias = safeName !== propName ? `, alias="${propName}"` : "";
+        if (!isRequired) {
+            lines.push(`    ${safeName}: ${pyType} = Field(None${alias})`);
+        }
+        else if (alias) {
+            lines.push(`    ${safeName}: ${pyType} = Field(...${alias})`);
+        }
+        else {
+            lines.push(`    ${safeName}: ${pyType}`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Ensure a property name is a valid Python identifier.
+ */
+function pythonSafeName(name) {
+    // Replace hyphens/dots with underscores
+    let safe = name.replace(/[-.\s]/g, "_");
+    // If it starts with a digit, prefix with underscore
+    if (/^\d/.test(safe)) {
+        safe = "_" + safe;
+    }
+    // Reserved words
+    const reserved = new Set([
+        "class",
+        "def",
+        "return",
+        "import",
+        "from",
+        "if",
+        "else",
+        "for",
+        "while",
+        "type",
+        "input",
+        "list",
+        "dict",
+        "set",
+        "str",
+        "int",
+        "float",
+        "bool",
+        "None",
+        "True",
+        "False",
+        "and",
+        "or",
+        "not",
+        "in",
+        "is",
+        "lambda",
+        "with",
+        "as",
+        "try",
+        "except",
+        "finally",
+        "raise",
+        "pass",
+        "break",
+        "continue",
+        "global",
+        "nonlocal",
+        "del",
+        "yield",
+        "assert",
+        "async",
+        "await",
+    ]);
+    if (reserved.has(safe)) {
+        safe = safe + "_";
+    }
+    return safe;
+}
+/**
+ * Check if a JSON Schema represents an object type (i.e. should become a Pydantic model).
+ */
+function isObjectSchema(schema) {
+    const core = extractCoreSchema(schema);
+    return core.type === "object" && !!core.properties;
+}
+/**
+ * Get the Python type for a non-object (primitive/array) JSON Schema.
+ */
+function primitiveSchemaToPythonType(schema, models) {
+    const core = extractCoreSchema(schema);
+    return jsonSchemaTypeToPython(core, "Anon", models);
+}
+/**
+ * Generate the models.py content, and return type info for each procedure.
+ */
+function generateModelsFile(procedures) {
+    const lines = [
+        "from __future__ import annotations",
+        "",
+        "from pydantic import BaseModel, Field",
+        "from typing import Any, Dict, List, Optional, Union",
+        "",
+        "",
+    ];
+    const allModels = [];
+    const typeInfo = [];
+    for (const proc of procedures) {
+        const pascal = toPascalCase(proc.name);
+        const info = {
+            name: proc.name,
+            inputIsModel: false,
+            inputPyType: "",
+            outputIsModel: false,
+            outputPyType: "dict",
+        };
+        if (proc.inputSchema) {
+            if (isObjectSchema(proc.inputSchema)) {
+                const inputName = `${pascal}Input`;
+                const coreSchema = extractCoreSchema(proc.inputSchema);
+                const code = generateModelClass(inputName, coreSchema, allModels);
+                allModels.push({ name: inputName, code });
+                info.inputIsModel = true;
+                info.inputPyType = inputName;
+            }
+            else {
+                info.inputIsModel = false;
+                info.inputPyType = primitiveSchemaToPythonType(proc.inputSchema, allModels);
+            }
+        }
+        if (proc.outputSchema) {
+            if (isObjectSchema(proc.outputSchema)) {
+                const outputName = `${pascal}Output`;
+                const coreSchema = extractCoreSchema(proc.outputSchema);
+                const code = generateModelClass(outputName, coreSchema, allModels);
+                allModels.push({ name: outputName, code });
+                info.outputIsModel = true;
+                info.outputPyType = outputName;
+            }
+            else {
+                info.outputIsModel = false;
+                info.outputPyType = primitiveSchemaToPythonType(proc.outputSchema, allModels);
+            }
+        }
+        typeInfo.push(info);
+    }
+    for (const model of allModels) {
+        lines.push(model.code);
+        lines.push("");
+        lines.push("");
+    }
+    return { content: lines.join("\n").trimEnd() + "\n", typeInfo };
+}
+/**
+ * Extract the core schema from a zod-to-json-schema output,
+ * which may wrap the actual schema in definitions/$ref.
+ */
+function extractCoreSchema(schema) {
+    if (schema.$ref && schema.definitions) {
+        const refName = schema.$ref.replace("#/definitions/", "");
+        return schema.definitions[refName] || schema;
+    }
+    return schema;
+}
+/**
+ * Generate the client.py content.
+ */
+function generateClientFile(procedures, typeInfo, baseUrl) {
+    const lines = [
+        "import httpx",
+        "import json",
+        "from urllib.parse import quote",
+        "from .models import *",
+        "",
+        "",
+        "class TRPCClient:",
+        '    def __init__(self, base_url: str = "' + baseUrl + '"):',
+        '        self.base_url = base_url.rstrip("/")',
+        "        self.http = httpx.Client()",
+        "",
+    ];
+    for (let i = 0; i < procedures.length; i++) {
+        const proc = procedures[i];
+        const info = typeInfo[i];
+        const snake = toSnakeCase(proc.name);
+        const hasInput = proc.inputSchema !== null;
+        const inputParam = hasInput ? `input: ${info.inputPyType}` : "";
+        const returnType = ` -> ${info.outputPyType}`;
+        lines.push(`    def ${snake}(self, ${inputParam})${returnType}:`);
+        lines.push(`        url = f"{self.base_url}/${proc.name}"`);
+        // Serialize input — models use .model_dump(), primitives are used directly
+        const inputExpr = hasInput
+            ? info.inputIsModel
+                ? "input.model_dump(by_alias=True)"
+                : "input"
+            : null;
+        if (proc.type === "query") {
+            if (inputExpr) {
+                lines.push(`        encoded = quote(json.dumps(${inputExpr}))`);
+                lines.push(`        resp = self.http.get(url, params={"input": encoded})`);
+            }
+            else {
+                lines.push(`        resp = self.http.get(url)`);
+            }
+        }
+        else {
+            if (inputExpr) {
+                lines.push(`        resp = self.http.post(url, json={"json": ${inputExpr}})`);
+            }
+            else {
+                lines.push(`        resp = self.http.post(url)`);
+            }
+        }
+        lines.push(`        resp.raise_for_status()`);
+        lines.push(`        data = resp.json()["result"]["data"]`);
+        if (info.outputIsModel) {
+            lines.push(`        return ${info.outputPyType}(**data)`);
+        }
+        else {
+            lines.push(`        return data`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd() + "\n";
+}
+/**
+ * Generate the __init__.py content.
+ */
+function generateInitFile() {
+    return `from .models import *\nfrom .client import TRPCClient\n`;
+}
+/**
+ * Main codegen function — writes the generated Python package to disk.
+ */
+export function generatePythonClient(config, procedures) {
+    const outputDir = resolve(process.cwd(), config.output.dir);
+    const packageDir = join(outputDir, config.output.package_name);
+    mkdirSync(packageDir, { recursive: true });
+    const { content: modelsContent, typeInfo } = generateModelsFile(procedures);
+    writeFileSync(join(packageDir, "models.py"), modelsContent);
+    const clientContent = generateClientFile(procedures, typeInfo, config.router.base_url);
+    writeFileSync(join(packageDir, "client.py"), clientContent);
+    const initContent = generateInitFile();
+    writeFileSync(join(packageDir, "__init__.py"), initContent);
+    console.log(`Generated Python client at ${packageDir}/`);
+    console.log(`  - models.py  (${procedures.length} procedure(s))`);
+    console.log(`  - client.py`);
+    console.log(`  - __init__.py`);
+}

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from "./types.js";
+export declare function loadConfig(configPath?: string): Config;

package/dist/config.js

@@ -0,0 +1,31 @@
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import TOML from "@iarna/toml";
+export function loadConfig(configPath) {
+    const filePath = configPath
+        ? resolve(configPath)
+        : resolve(process.cwd(), "trpc-gen-python.toml");
+    let raw;
+    try {
+        raw = readFileSync(filePath, "utf-8");
+    }
+    catch {
+        throw new Error(`Config file not found: ${filePath}`);
+    }
+    const parsed = TOML.parse(raw);
+    if (!parsed.router?.path) {
+        throw new Error("Config missing required field: router.path");
+    }
+    if (!parsed.router?.base_url) {
+        throw new Error("Config missing required field: router.base_url");
+    }
+    if (!parsed.output?.dir) {
+        throw new Error("Config missing required field: output.dir");
+    }
+    if (!parsed.endpoints || parsed.endpoints.length === 0) {
+        throw new Error("Config must specify at least one endpoint pattern in endpoints = [...]");
+    }
+    parsed.router.export = parsed.router.export || "appRouter";
+    parsed.output.package_name = parsed.output.package_name || "trpc_client";
+    return parsed;
+}

package/dist/infer-outputs.d.ts

@@ -0,0 +1,10 @@
+import type { JSONSchema } from "./types.js";
+/**
+ * Use the TypeScript compiler to infer output types for procedures
+ * that don't have an explicit .output() Zod schema.
+ *
+ * Works by resolving `inferRouterOutputs<AppRouter>` and navigating
+ * the resulting type to extract each procedure's output type,
+ * then converting that TS type to JSON Schema.
+ */
+export declare function inferOutputTypes(routerPath: string, routerExport: string, procedureNames: string[]): Map<string, JSONSchema>;

package/dist/infer-outputs.js

@@ -0,0 +1,165 @@
+import { Project } from "ts-morph";
+import { resolve, dirname } from "path";
+import { accessSync } from "fs";
+/**
+ * Use the TypeScript compiler to infer output types for procedures
+ * that don't have an explicit .output() Zod schema.
+ *
+ * Works by resolving `inferRouterOutputs<AppRouter>` and navigating
+ * the resulting type to extract each procedure's output type,
+ * then converting that TS type to JSON Schema.
+ */
+export function inferOutputTypes(routerPath, routerExport, procedureNames) {
+    const absRouterPath = resolve(process.cwd(), routerPath);
+    // Find the user's tsconfig
+    const tsConfigPath = findTsConfig(dirname(absRouterPath));
+    const project = new Project({
+        tsConfigFilePath: tsConfigPath,
+        skipAddingFilesFromTsConfig: true,
+    });
+    // Add the router file so the project can resolve it
+    project.addSourceFileAtPath(absRouterPath);
+    // Create a virtual file that uses inferRouterOutputs
+    const virtualSource = project.createSourceFile("__trpc_gen_virtual__.ts", `
+import type { inferRouterOutputs } from "@trpc/server";
+import type { ${routerExport} } from "${absRouterPath.replace(/\.ts$/, "")}";
+type _AppRouter = typeof ${routerExport};
+type _Outputs = inferRouterOutputs<_AppRouter>;
+`, { overwrite: true });
+    const outputsAlias = virtualSource.getTypeAliasOrThrow("_Outputs");
+    const outputsType = outputsAlias.getType();
+    const results = new Map();
+    for (const procName of procedureNames) {
+        // "calls.getById" → navigate type via ["calls"]["getById"]
+        const segments = procName.split(".");
+        let currentType = outputsType;
+        let resolved = true;
+        for (const segment of segments) {
+            const prop = currentType.getProperty(segment);
+            if (!prop) {
+                resolved = false;
+                break;
+            }
+            currentType = prop.getTypeAtLocation(virtualSource);
+        }
+        if (resolved) {
+            const schema = tsTypeToJsonSchema(currentType, virtualSource, new Set());
+            results.set(procName, schema);
+        }
+    }
+    return results;
+}
+/**
+ * Find the nearest tsconfig.json starting from a directory.
+ */
+function findTsConfig(startDir) {
+    let dir = startDir;
+    while (true) {
+        const candidate = resolve(dir, "tsconfig.json");
+        try {
+            accessSync(candidate);
+            return candidate;
+        }
+        catch {
+            const parent = dirname(dir);
+            if (parent === dir) {
+                throw new Error(`Could not find tsconfig.json starting from ${startDir}`);
+            }
+            dir = parent;
+        }
+    }
+}
+/**
+ * Convert a TypeScript type to a JSON Schema representation.
+ */
+function tsTypeToJsonSchema(type, location, seen) {
+    // Handle Promise<T> → unwrap to T
+    if (type.getSymbol()?.getName() === "Promise" || type.getText().startsWith("Promise<")) {
+        const typeArgs = type.getTypeArguments();
+        if (typeArgs.length > 0) {
+            return tsTypeToJsonSchema(typeArgs[0], location, seen);
+        }
+    }
+    // Primitives
+    if (type.isString() || type.isStringLiteral()) {
+        return { type: "string" };
+    }
+    if (type.isNumber() || type.isNumberLiteral()) {
+        return { type: "number" };
+    }
+    if (type.isBoolean() || type.isBooleanLiteral()) {
+        return { type: "boolean" };
+    }
+    if (type.isNull()) {
+        return { type: "null" };
+    }
+    if (type.isUndefined()) {
+        return { type: "null" };
+    }
+    // Union types (but not boolean which shows as true | false)
+    if (type.isUnion() && !type.isBoolean()) {
+        const unionTypes = type.getUnionTypes();
+        // Filter out undefined for optional handling
+        const nonUndefined = unionTypes.filter((t) => !t.isUndefined());
+        const hasUndefined = unionTypes.some((t) => t.isUndefined());
+        if (nonUndefined.length === 1) {
+            const inner = tsTypeToJsonSchema(nonUndefined[0], location, seen);
+            if (hasUndefined) {
+                return { anyOf: [inner, { type: "null" }] };
+            }
+            return inner;
+        }
+        const schemas = nonUndefined.map((t) => tsTypeToJsonSchema(t, location, seen));
+        return { anyOf: schemas };
+    }
+    // Arrays
+    if (type.isArray()) {
+        const elementType = type.getArrayElementTypeOrThrow();
+        return {
+            type: "array",
+            items: tsTypeToJsonSchema(elementType, location, seen),
+        };
+    }
+    // Date → string
+    if (type.getSymbol()?.getName() === "Date") {
+        return { type: "string" };
+    }
+    // Object / interface types
+    if (type.isObject() && !type.isArray()) {
+        const typeText = type.getText();
+        // Guard against infinite recursion for recursive types
+        if (seen.has(typeText)) {
+            return { type: "object" };
+        }
+        seen.add(typeText);
+        const properties = {};
+        const required = [];
+        for (const prop of type.getProperties()) {
+            const propName = prop.getName();
+            // Skip internal/private properties
+            if (propName.startsWith("_"))
+                continue;
+            const propType = prop.getTypeAtLocation(location);
+            const isOptional = prop.isOptional();
+            let propSchema = tsTypeToJsonSchema(propType, location, new Set(seen));
+            // If the prop type is a union with undefined (from optional), unwrap it
+            if (isOptional && propSchema.anyOf) {
+                const nonNull = propSchema.anyOf.filter((s) => s.type !== "null");
+                if (nonNull.length === 1) {
+                    propSchema = nonNull[0];
+                }
+            }
+            properties[propName] = propSchema;
+            if (!isOptional) {
+                required.push(propName);
+            }
+        }
+        const schema = { type: "object", properties };
+        if (required.length > 0) {
+            schema.required = required;
+        }
+        return schema;
+    }
+    // Fallback
+    return {};
+}

package/dist/introspect.d.ts

@@ -0,0 +1,2 @@
+import type { Config, ProcedureInfo } from "./types.js";
+export declare function introspectRouter(config: Config): Promise<ProcedureInfo[]>;

package/dist/introspect.js

@@ -0,0 +1,146 @@
+import { resolve, dirname } from "path";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { inferOutputTypes } from "./infer-outputs.js";
+export async function introspectRouter(config) {
+    const routerPath = resolve(process.cwd(), config.router.path);
+    // Use tsx to register TypeScript loader before importing
+    const tsxPath = resolve(dirname(new URL(import.meta.url).pathname), "..", "node_modules", "tsx", "esm", "api.mjs");
+    // Register tsx so we can import .ts files
+    try {
+        const tsx = await import(tsxPath);
+        if (tsx.register) {
+            tsx.register();
+        }
+    }
+    catch {
+        // tsx may already be registered if running via tsx
+    }
+    const routerModule = await import(routerPath);
+    const router = routerModule[config.router.export];
+    if (!router) {
+        throw new Error(`Export "${config.router.export}" not found in ${config.router.path}`);
+    }
+    const procedures = router._def.procedures;
+    const allProcNames = Object.keys(procedures);
+    // Resolve glob patterns against the full procedure list
+    const matchedNames = resolveEndpointPatterns(config.endpoints, allProcNames);
+    if (matchedNames.length === 0) {
+        throw new Error(`No procedures matched the patterns: ${config.endpoints.join(", ")}. Available: ${allProcNames.join(", ")}`);
+    }
+    const results = [];
+    // First pass: extract runtime schemas and identify procedures missing output
+    const needsInference = [];
+    for (const name of matchedNames) {
+        const procedure = procedures[name];
+        const procDef = procedure._def;
+        const procedureType = procDef.type === "mutation" ? "mutation" : "query";
+        // Extract input schema (tRPC v11 uses inputs array)
+        let inputSchema = null;
+        const inputs = procDef.inputs;
+        if (inputs && inputs.length > 0) {
+            if (inputs.length === 1) {
+                inputSchema = zodToJsonSchema(inputs[0], {
+                    target: "jsonSchema7",
+                });
+            }
+            else {
+                const schemas = inputs.map((i) => zodToJsonSchema(i, { target: "jsonSchema7" }));
+                inputSchema = mergeObjectSchemas(schemas);
+            }
+        }
+        // Extract output schema from explicit .output()
+        let outputSchema = null;
+        if (procDef.output) {
+            outputSchema = zodToJsonSchema(procDef.output, {
+                target: "jsonSchema7",
+            });
+        }
+        else {
+            needsInference.push(name);
+        }
+        results.push({
+            name,
+            type: procedureType,
+            inputSchema,
+            outputSchema,
+        });
+    }
+    // Second pass: use TS compiler to infer output types for procedures without .output()
+    if (needsInference.length > 0) {
+        console.log(`Inferring output types via TypeScript compiler for: ${needsInference.join(", ")}`);
+        const inferred = inferOutputTypes(config.router.path, config.router.export, needsInference);
+        for (const result of results) {
+            if (!result.outputSchema && inferred.has(result.name)) {
+                result.outputSchema = inferred.get(result.name);
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Convert a glob-like endpoint pattern to a RegExp.
+ * Supports:
+ *   - "*" matches any characters within a single segment (between dots)
+ *   - "**" matches any number of segments (including zero)
+ *   - Exact names match literally
+ *
+ * Examples:
+ *   "user.*"       → matches "user.getById", "user.create"
+ *   "user.**"      → matches "user.getById", "user.profile.update"
+ *   "*.list"       → matches "post.list", "comment.list"
+ *   "**"           → matches everything
+ *   "user.getById" → matches exactly "user.getById"
+ */
+function patternToRegex(pattern) {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&") // escape regex chars (dot included)
+        .replace(/\\\.\*\*/g, "(?:\\.[^.]+)*") // ".**" → zero or more .segments
+        .replace(/\*\*/g, ".*") // standalone "**" → anything
+        .replace(/\*/g, "[^.]+"); // "*" → one segment (no dots)
+    return new RegExp(`^${escaped}$`);
+}
+/**
+ * Resolve an array of glob patterns against the full list of procedure names.
+ * Returns a deduplicated list in stable order (matching the order procedures appear in the router).
+ */
+function resolveEndpointPatterns(patterns, allNames) {
+    const matched = new Set();
+    for (const pattern of patterns) {
+        const regex = patternToRegex(pattern);
+        let found = false;
+        for (const name of allNames) {
+            if (regex.test(name)) {
+                matched.add(name);
+                found = true;
+            }
+        }
+        if (!found) {
+            console.warn(`Warning: pattern "${pattern}" did not match any procedures`);
+        }
+    }
+    // Return in the order they appear in the router
+    return allNames.filter((name) => matched.has(name));
+}
+/**
+ * Merge multiple JSON Schemas (all assumed to be objects) into one
+ * by combining their properties and required arrays.
+ */
+function mergeObjectSchemas(schemas) {
+    const merged = {
+        type: "object",
+        properties: {},
+        required: [],
+    };
+    for (const schema of schemas) {
+        if (schema.properties) {
+            Object.assign(merged.properties, schema.properties);
+        }
+        if (schema.required) {
+            merged.required.push(...schema.required);
+        }
+    }
+    if (merged.required.length === 0) {
+        delete merged.required;
+    }
+    return merged;
+}

package/dist/types.d.ts

@@ -0,0 +1,36 @@
+export interface RouterConfig {
+    path: string;
+    export: string;
+    base_url: string;
+}
+export interface OutputConfig {
+    dir: string;
+    package_name: string;
+}
+export interface Config {
+    router: RouterConfig;
+    output: OutputConfig;
+    endpoints: string[];
+}
+export interface JSONSchema {
+    type?: string;
+    properties?: Record<string, JSONSchema>;
+    required?: string[];
+    items?: JSONSchema;
+    enum?: unknown[];
+    $ref?: string;
+    definitions?: Record<string, JSONSchema>;
+    anyOf?: JSONSchema[];
+    allOf?: JSONSchema[];
+    oneOf?: JSONSchema[];
+    default?: unknown;
+    description?: string;
+    additionalProperties?: boolean | JSONSchema;
+    nullable?: boolean;
+}
+export interface ProcedureInfo {
+    name: string;
+    type: "query" | "mutation";
+    inputSchema: JSONSchema | null;
+    outputSchema: JSONSchema | null;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "trpc-gen-python",
+  "version": "0.1.0",
+  "description": "Generate Python (Pydantic + httpx) clients from tRPC routers",
+  "type": "module",
+  "main": "./dist/cli.js",
+  "bin": {
+    "trpc-gen-python": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "trpc",
+    "python",
+    "codegen",
+    "pydantic",
+    "httpx",
+    "type-safe",
+    "api-client"
+  ],
+  "author": "Ishan Das Sharma",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sad-pixel/trpc-gen-python.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sad-pixel/trpc-gen-python/issues"
+  },
+  "homepage": "https://github.com/sad-pixel/trpc-gen-python#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "commander": "^12.1.0",
+    "ts-morph": "^27.0.2",
+    "tsx": "^4.19.0",
+    "zod-to-json-schema": "^3.23.0"
+  },
+  "devDependencies": {
+    "@trpc/server": "^11.0.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0",
+    "zod": "^3.23.0"
+  },
+  "peerDependencies": {
+    "@trpc/server": "^11.0.0",
+    "zod": "^3.23.0"
+  }
+}