将TypeScript推断类型转换为JSON模式表示的编程指南

// my-ts-file.ts
const inner = {
  hello: "world",
};

export const value = {
  prop1: "hello",
  prop2: "world",
  prop3: 42,
  prop4: inner,
};

const value: {
    prop1: string;
    prop2: string;
    prop3: number;
    prop4: {
        hello: string;
    };
}

{
    "prop1": "string",
    "prop2": "string",
    "prop3": "number",
    "prop4": {
        "hello": "string"
    }
}

{
    "prop1": "hello",
    "prop2": "world",
    "prop3": 42,
    "prop4": {
        "hello": "world"
    }
}

npm install typescript

// my-ts-file.ts
const inner = {
  hello: "world",
};

export const value = {
  prop1: "hello",
  prop2: "world",
  prop3: 42,
  prop4: inner,
};

export const anotherValue = {
  items: [1, 2, 3],
  status: "active",
};

import * as ts from 'typescript';
import * as path from 'path';

/**
 * 将TypeScript类型对象转换为其对应的字符串名称。
 * @param typeChecker TypeScript类型检查器实例。
 * @param type TypeScript类型对象。
 * @returns 类型的字符串表示（如 "string", "number", "boolean", "object", "array"）。
 */
function getTypeString(typeChecker: ts.TypeChecker, type: ts.Type): string {
    if (type.flags & ts.TypeFlags.String) {
        return "string";
    }
    if (type.flags & ts.TypeFlags.Number) {
        return "number";
    }
    if (type.flags & ts.TypeFlags.Boolean) {
        return "boolean";
    }
    if (type.flags & ts.TypeFlags.Null) {
        return "null";
    }
    if (type.flags & ts.TypeFlags.Undefined) {
        return "undefined";
    }
    if (type.flags & ts.TypeFlags.Any) {
        return "any";
    }
    if (type.flags & ts.TypeFlags.Void) {
        return "void";
    }
    if (type.flags & ts.TypeFlags.Unknown) {
        return "unknown";
    }
    if (type.flags & ts.TypeFlags.BigInt) {
        return "bigint";
    }
    if (type.flags & ts.TypeFlags.ESSymbol) {
        return "symbol";
    }

    // 检查是否为数组类型
    if (typeChecker.isArrayLikeType(type)) {
        const elementType = typeChecker.getTypeArguments(type as ts.TypeReference)[0];
        if (elementType) {
            return getTypeString(typeChecker, elementType) + "[]";
        }
        return "any[]"; // 无法确定元素类型
    }

    // 检查是否为对象类型（包括字面量对象和接口）
    if (type.flags & ts.TypeFlags.Object || typeChecker.getPropertiesOfType(type).length > 0) {
        return "object";
    }

    // 默认返回类型文本，这对于更复杂的类型（如联合类型、字面量类型）可能更精确
    return typeChecker.typeToString(type);
}

/**
 * 递归地将TypeScript类型转换为JSON模式表示。
 * @param typeChecker TypeScript类型检查器实例。
 * @param type TypeScript类型对象。
 * @returns 对应的JSON模式对象。
 */
function convertTypeToJsonSchema(typeChecker: ts.TypeChecker, type: ts.Type): any {
    // 检查是否为原始类型
    const primitiveType = getTypeString(typeChecker, type);
    if (primitiveType !== "object" && !primitiveType.endsWith("[]")) {
        return primitiveType;
    }

    // 检查是否为数组类型
    if (typeChecker.isArrayLikeType(type)) {
        const elementType = typeChecker.getTypeArguments(type as ts.TypeReference)[0];
        return [elementType ? convertTypeToJsonSchema(typeChecker, elementType) : "any"];
    }

    // 处理对象类型
    const properties: { [key: string]: any } = {};
    const symbol = type.getSymbol();

    if (symbol && symbol.declarations && symbol.declarations.length > 0) {
        // 尝试从声明中获取属性（例如接口或类型别名）
        const declaration = symbol.declarations[0];
        if (ts.isInterfaceDeclaration(declaration) || ts.isTypeAliasDeclaration(declaration)) {
            typeChecker.getPropertiesOfType(type).forEach(prop => {
                const propType = typeChecker.getTypeOfSymbolAtLocation(prop, declaration);
                properties[prop.getName()] = convertTypeToJsonSchema(typeChecker, propType);
            });
            return properties;
        }
    }

    // 对于匿名对象字面量，直接获取其属性
    typeChecker.getPropertiesOfType(type).forEach(prop => {
        const propType = typeChecker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration || prop.declarations[0]);
        properties[prop.getName()] = convertTypeToJsonSchema(typeChecker, propType);
    });

    return properties;
}

/**
 * 提取指定文件中导出变量的类型并转换为JSON模式。
 * @param filePath 目标TypeScript文件的路径。
 * @param variableName 目标导出变量的名称。
 * @returns 包含类型模式的JSON对象，如果未找到则为null。
 */
function extractExportedVariableTypeAsJson(filePath: string, variableName: string): any | null {
    const program = ts.createProgram([filePath], {
        target: ts.ScriptTarget.ESNext,
        module: ts.ModuleKind.CommonJS,
        strict: true,
        // 如果你的项目有tsconfig.json，可以这样加载
        // project: path.dirname(filePath)
    });

    const sourceFile = program.getSourceFile(filePath);
    if (!sourceFile) {
        console.error(`Error: Could not find source file at ${filePath}`);
        return null;
    }

    const typeChecker = program.getTypeChecker();
    let result: any | null = null;

    ts.forEachChild(sourceFile, node => {
        // 查找 `export const variableName = ...`
        if (ts.isVariableStatement(node) && node.modifiers &&
            node.modifiers.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
            node.declarationList.declarations.forEach(declaration => {
                if (ts.isIdentifier(declaration.name) && declaration.name.text === variableName) {
                    const symbol = typeChecker.getSymbolAtLocation(declaration.name);
                    if (symbol) {
                        const type = typeChecker.getTypeOfSymbolAtLocation(symbol, declaration.name);
                        result = convertTypeToJsonSchema(typeChecker, type);
                    }
                }
            });
        }
    });

    return result;
}

// 示例用法
const tsFilePath = path.join(__dirname, 'my-ts-file.ts');

const valueTypeJson = extractExportedVariableTypeAsJson(tsFilePath, 'value');
if (valueTypeJson) {
    console.log(`Type schema for 'value':\n${JSON.stringify(valueTypeJson, null, 2)}`);
}

const anotherValueTypeJson = extractExportedVariableTypeAsJson(tsFilePath, 'anotherValue');
if (anotherValueTypeJson) {
    console.log(`\nType schema for 'anotherValue':\n${JSON.stringify(anotherValueTypeJson, null, 2)}`);
}

Type schema for 'value':
{
  "prop1": "string",
  "prop2": "string",
  "prop3": "number",
  "prop4": {
    "hello": "string"
  }
}

Type schema for 'anotherValue':
{
  "items": [
    "number"
  ],
  "status": "string"
}