@qwe8652591/abap-recursive-query 1.1.0

package/dist/recursive/generate/structureGenerator.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 结构体生成器
+ * 生成ABAP结构体定义文件
+ */
+import { StructureDefinition, StructureField } from '../abapStructures';
+/**
+ * 生成结构体内容
+ */
+export declare function generateStructureContent(structure: StructureDefinition): string;
+/**
+ * 生成传统ABAP字段行
+ */
+export declare function generateFieldLine(field: StructureField): string;
+/**
+ * 生成传统字段类型定义
+ */
+export declare function generateFieldType(field: Pick<StructureField, 'FIELDNAME' | 'ROLLNAME' | 'DOMNAME' | 'DATATYPE' | 'LENG'>): string;
+/**
+ * 将ABAP数据类型映射到传统ABAP类型
+ */
+export declare function mapDataTypeToTraditional(abapType: string): string;
+//# sourceMappingURL=structureGenerator.d.ts.map

package/dist/recursive/generate/structureGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structureGenerator.d.ts","sourceRoot":"","sources":["../../../src/recursive/generate/structureGenerator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExE;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,mBAAmB,GAAG,MAAM,CAgB/E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAc/D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC,GAAG,MAAM,CAsBjI;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAoBjE"}

package/dist/recursive/generate/structureGenerator.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * 结构体生成器
+ * 生成ABAP结构体定义文件
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStructureContent = generateStructureContent;
+exports.generateFieldLine = generateFieldLine;
+exports.generateFieldType = generateFieldType;
+exports.mapDataTypeToTraditional = mapDataTypeToTraditional;
+/**
+ * 生成结构体内容
+ */
+function generateStructureContent(structure) {
+    let content = `*----------------------------------------------------------------------*\n`;
+    content += `* ${structure.TABLETITLE || structure.TABLENAME}\n`;
+    content += `*----------------------------------------------------------------------*\n`;
+    content += `TYPES: BEGIN OF ty_${structure.TABLENAME.toLowerCase()},\n`;
+    if (structure.ISTRUCTURE && structure.ISTRUCTURE.length > 0) {
+        const sortedFields = structure.ISTRUCTURE.sort((a, b) => a.POSITION - b.POSITION);
+        for (const field of sortedFields) {
+            content += generateFieldLine(field);
+        }
+    }
+    content += `       END OF ty_${structure.TABLENAME.toLowerCase()}.`;
+    return content;
+}
+/**
+ * 生成传统ABAP字段行
+ */
+function generateFieldLine(field) {
+    // 忽略 .INCLUDE 字段
+    if (field.FIELDNAME === '.INCLUDE') {
+        return '';
+    }
+    let fieldLine = `         ${field.FIELDNAME.toLowerCase()}`;
+    fieldLine += generateFieldType(field);
+    if (field.DDTEXT) {
+        fieldLine += `, "${field.DDTEXT.replace(/"/g, '""')}"`;
+    }
+    return fieldLine + ',\n';
+}
+/**
+ * 生成传统字段类型定义
+ */
+function generateFieldType(field) {
+    if (field.FIELDNAME === '.INCLUDE' && field.ROLLNAME) {
+        // return ` TYPE ${field.ROLLNAME.toLowerCase()}`;
+    }
+    if (field.ROLLNAME) {
+        return ` TYPE ${field.ROLLNAME.toLowerCase()}`;
+    }
+    if (field.DOMNAME) {
+        return ` TYPE ${field.DOMNAME.toLowerCase()}`;
+    }
+    if (field.DATATYPE) {
+        let typeDef = ` TYPE ${mapDataTypeToTraditional(field.DATATYPE)}`;
+        if (field.LENG && field.LENG > 0) {
+            typeDef += ` LENGTH ${field.LENG}`;
+        }
+        return typeDef;
+    }
+    return '';
+}
+/**
+ * 将ABAP数据类型映射到传统ABAP类型
+ */
+function mapDataTypeToTraditional(abapType) {
+    const typeMap = {
+        'CHAR': 'c',
+        'NUMC': 'n',
+        'INT4': 'i',
+        'INT2': 's',
+        'INT1': 'b',
+        'DEC': 'p',
+        'CURR': 'p',
+        'QUAN': 'p',
+        'UNIT': 'c',
+        'CUKY': 'c',
+        'DATS': 'd',
+        'TIMS': 't',
+        'STRING': 'string',
+        'RAW': 'x',
+        'CLNT': 'c',
+        'LANG': 'c'
+    };
+    return typeMap[abapType.toUpperCase()] || abapType.toLowerCase();
+}

package/dist/recursive/generate/textElementGenerator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 文本元素生成器
+ * 生成文本元素XML文件
+ */
+import { TextElement } from '../abapStructures';
+/**
+ * 生成文本元素XML内容
+ * 遵循abapGit协议格式
+ */
+export declare function generateTextElementsXmlContent(textElements: TextElement[], objectName: string, objectType: string): string;
+/**
+ * 生成文本元素XML文件
+ * 符合abapGit协议规范
+ */
+export declare function generateTextElementsXml(textElements: TextElement[], objectName: string, objectType: string, downloadRootPath: string, resultDownloadedFiles: any[]): Promise<void>;
+//# sourceMappingURL=textElementGenerator.d.ts.map

package/dist/recursive/generate/textElementGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textElementGenerator.d.ts","sourceRoot":"","sources":["../../../src/recursive/generate/textElementGenerator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD;;;GAGG;AACH,wBAAgB,8BAA8B,CAC1C,YAAY,EAAE,WAAW,EAAE,EAC3B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACnB,MAAM,CAuBR;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CACzC,YAAY,EAAE,WAAW,EAAE,EAC3B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,gBAAgB,EAAE,MAAM,EACxB,qBAAqB,EAAE,GAAG,EAAE,GAC7B,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/dist/recursive/generate/textElementGenerator.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * 文本元素生成器
+ * 生成文本元素XML文件
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTextElementsXmlContent = generateTextElementsXmlContent;
+exports.generateTextElementsXml = generateTextElementsXml;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const baseGenerator_1 = require("./baseGenerator");
+/**
+ * 生成文本元素XML内容
+ * 遵循abapGit协议格式
+ */
+function generateTextElementsXmlContent(textElements, objectName, objectType) {
+    let xml = '<?xml version="1.0" encoding="utf-8"?>\n';
+    xml += '<abapGit version="v1.0.0" serializer="LCL_OBJECT_TEXTS" serializer_version="v1.0.0">\n';
+    xml += '  <asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">\n';
+    xml += '    <asx:values>\n';
+    xml += '      <TEXT_ELEMENTS>\n';
+    for (const textElement of textElements) {
+        if (textElement.KEY && textElement.ENTRY) {
+            xml += '        <TEXT_ELEMENT>\n';
+            xml = (0, baseGenerator_1.addXmlField)(xml, 'KEY', textElement.KEY, '          ');
+            xml = (0, baseGenerator_1.addXmlField)(xml, 'TEXT', textElement.ENTRY, '          ');
+            xml = (0, baseGenerator_1.addXmlNumericField)(xml, 'LENGTH', textElement.LENGTH, '          ');
+            xml += '        </TEXT_ELEMENT>\n';
+        }
+    }
+    xml += '      </TEXT_ELEMENTS>\n';
+    xml += '    </asx:values>\n';
+    xml += '  </asx:abap>\n';
+    xml += '</abapGit>\n';
+    return xml;
+}
+/**
+ * 生成文本元素XML文件
+ * 符合abapGit协议规范
+ */
+async function generateTextElementsXml(textElements, objectName, objectType, downloadRootPath, resultDownloadedFiles) {
+    const safeObjectName = objectName.replace(/[/\\]/g, '_');
+    // 文本元素文件路径：/texts目录下
+    const baseDir = (0, path_1.join)(downloadRootPath, 'texts');
+    if (!(0, fs_1.existsSync)(baseDir)) {
+        (0, fs_1.mkdirSync)(baseDir, { recursive: true });
+    }
+    // 生成符合abapGit协议的XML内容
+    const xmlContent = generateTextElementsXmlContent(textElements, objectName, objectType);
+    // 按照abapGit协议命名规范，文本元素通常集成到主文件中
+    // 如果需要单独导出，使用：{对象名}.texts.xml
+    const xmlFileName = `${safeObjectName}.texts.xml`;
+    const xmlFilePath = (0, path_1.join)(baseDir, xmlFileName);
+    (0, fs_1.writeFileSync)(xmlFilePath, xmlContent, 'utf-8');
+    console.error(`导出文本元素 ${objectName} 到: ${xmlFilePath}`);
+    // 记录下载统计
+    resultDownloadedFiles.push({
+        objectName: objectName,
+        objectType: 'TEXT_ELEMENTS',
+        filePath: xmlFilePath,
+        success: true,
+        metadata: {
+            elementCount: textElements.length,
+            exportType: 'separate',
+            objectType: objectType
+        }
+    });
+}

package/dist/recursive/handleRecursiveObjectQuery.d.ts

@@ -0,0 +1,94 @@
+import { RecursiveQueryConfig } from './recursiveQueryConfig';
+/**
+ * 处理递归对象查询请求
+ * @param args 查询参数
+ * @returns 查询结果
+ */
+export declare function handleRecursiveObjectQuery(args: any): Promise<{
+    success: boolean;
+    data: {
+        original_object: any;
+        all_objects: {
+            object_key: string;
+            object_data: any;
+        }[];
+        downloaded_files: {
+            objectName: string;
+            objectType: string;
+            filePath: string;
+            success: boolean;
+            error?: string;
+            metadata?: any;
+        }[];
+        filtered_objects: {
+            objectType: string;
+            objectName: string;
+            reason: string;
+            filterType: "exact" | "pattern";
+            filterRule?: string;
+            timestamp: Date;
+        }[];
+        statistics: {
+            totalObjects: number;
+            totalClasses: number;
+            totalFunctions: number;
+            totalPrograms: number;
+            totalIncludes: number;
+            totalStructures: number;
+            totalDomains: number;
+            downloadedIncludes: number;
+            downloadedStructures: number;
+            downloadedDomains: number;
+            maxDepthReached: number;
+            circularReferences: number;
+        };
+        errors: string[];
+        summary: string;
+    };
+    message: string;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data: null;
+    message?: undefined;
+}>;
+/**
+ * 批量递归查询
+ * @param queries 查询列表
+ * @param config 全局配置
+ * @returns 批量查询结果
+ *
+ * 优化说明：
+ * 1. 顺序执行避免创建过多的独立任务队列
+ * 2. 每个查询创建独立的 RecursiveObjectQuery 实例，避免状态污染
+ * 3. 查询间添加适当延迟，避免服务器过载
+ */
+export declare function handleBatchRecursiveQuery(queries: Array<{
+    object_type: string;
+    object_name: string;
+}>, config?: Partial<RecursiveQueryConfig>): Promise<{
+    success: boolean;
+    data: {
+        results: any[];
+        errors: any[];
+        failed_files: any[];
+        summary: {
+            total_queries: number;
+            successful_queries: number;
+            failed_queries: number;
+            failed_files: number;
+            success_rate: string;
+            total_duration_ms: number;
+            average_duration_ms: number;
+        };
+    };
+    message: string;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data: null;
+    message?: undefined;
+}>;
+//# sourceMappingURL=handleRecursiveObjectQuery.d.ts.map

package/dist/recursive/handleRecursiveObjectQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleRecursiveObjectQuery.d.ts","sourceRoot":"","sources":["../../src/recursive/handleRecursiveObjectQuery.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAG9D;;;;GAIG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEzD;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,KAAK,CAAC;IAC3D,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACvB,CAAC,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;GAmJzC"}

package/dist/recursive/handleRecursiveObjectQuery.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRecursiveObjectQuery = handleRecursiveObjectQuery;
+exports.handleBatchRecursiveQuery = handleBatchRecursiveQuery;
+const recursiveObjectQuery_1 = require("./recursiveObjectQuery");
+const utils_1 = require("../lib/utils");
+/**
+ * 处理递归对象查询请求
+ * @param args 查询参数
+ * @returns 查询结果
+ */
+async function handleRecursiveObjectQuery(args) {
+    try {
+        // 验证必要参数
+        if (!args?.object_type) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Object type is required');
+        }
+        if (!args?.object_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Object name is required');
+        }
+        // 构建配置
+        const config = {
+            maxRecursionDepth: args.max_recursion_depth || 1,
+            downloadRootPath: args.download_root_path,
+            downloadIncludes: args.download_includes !== false,
+            downloadStructures: args.download_structures !== false,
+            recursiveClasses: args.recursive_classes !== false,
+            recursiveFunctions: args.recursive_functions !== false,
+            enableCircularReferenceCheck: args.enable_circular_reference_check !== false,
+            concurrentRequestLimit: args.concurrent_request_limit || 10,
+            requestInterval: args.request_interval || 100,
+            recursionFilters: args.recursion_filters
+        };
+        console.error(`开始递归查询 - 类型: ${args.object_type}, 名称: ${args.object_name}`);
+        console.error(`配置: ${JSON.stringify(config, null, 2)}`);
+        // 创建查询器并执行
+        const query = new recursiveObjectQuery_1.RecursiveObjectQuery(config);
+        const result = await query.execute(args.object_type.toUpperCase(), args.object_name.toUpperCase());
+        // 生成摘要信息
+        const summary = query.getResultSummary();
+        console.error(summary);
+        // 获取文件错误详情
+        const fileErrorDetails = query.getFileErrorDetails();
+        if (fileErrorDetails) {
+            console.error(fileErrorDetails);
+        }
+        // 返回结果 - 避免循环引用问题
+        return {
+            success: true,
+            data: {
+                original_object: result.originalObject,
+                all_objects: Array.from(result.allObjects.entries()).map(([key, value]) => ({
+                    object_key: key,
+                    object_data: value
+                })).slice(0, 20), // 限制输出数量，避免过多数据
+                downloaded_files: result.downloadedFiles,
+                filtered_objects: result.filteredObjects,
+                statistics: result.statistics,
+                errors: result.errors,
+                summary: summary
+            },
+            message: `递归查询完成 - 处理了 ${result.statistics.totalObjects} 个对象，过滤了 ${result.filteredObjects.length} 个对象`
+        };
+    }
+    catch (error) {
+        const errorMessage = `递归查询失败: ${error instanceof Error ? error.message : String(error)}`;
+        console.error(errorMessage);
+        return {
+            success: false,
+            error: errorMessage,
+            data: null
+        };
+    }
+}
+/**
+ * 批量递归查询
+ * @param queries 查询列表
+ * @param config 全局配置
+ * @returns 批量查询结果
+ *
+ * 优化说明：
+ * 1. 顺序执行避免创建过多的独立任务队列
+ * 2. 每个查询创建独立的 RecursiveObjectQuery 实例，避免状态污染
+ * 3. 查询间添加适当延迟，避免服务器过载
+ */
+async function handleBatchRecursiveQuery(queries, config) {
+    try {
+        if (!queries || !Array.isArray(queries) || queries.length === 0) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Queries array is required and cannot be empty');
+        }
+        console.error(`开始批量递归查询 - 共 ${queries.length} 个查询`);
+        console.error(`配置: ${JSON.stringify(config, null, 2)}`);
+        const results = [];
+        const errors = [];
+        const fileErrors = [];
+        const startTime = Date.now();
+        // 顺序执行查询以避免过载
+        // 每个查询有自己的独立任务队列，可以并发处理内部的对象
+        for (let i = 0; i < queries.length; i++) {
+            const query = queries[i];
+            const queryStartTime = Date.now();
+            console.error(`\n处理第 ${i + 1}/${queries.length} 个查询: ${query.object_type} - ${query.object_name}`);
+            console.error('----------------------------------------');
+            try {
+                const result = await handleRecursiveObjectQuery({
+                    ...query,
+                    ...config
+                });
+                const queryDuration = Date.now() - queryStartTime;
+                console.error(`查询 ${i + 1} 完成，耗时: ${queryDuration}ms`);
+                if (result.success) {
+                    results.push({
+                        query: query,
+                        result: result.data,
+                        index: i,
+                        duration: queryDuration
+                    });
+                    // 从 downloadedFiles 中收集失败的文件信息
+                    if (result.data?.downloaded_files && result.data.downloaded_files.length > 0) {
+                        const failedFiles = result.data.downloaded_files.filter((f) => !f.success);
+                        fileErrors.push(...failedFiles.map((file) => ({
+                            objectType: file.objectType,
+                            objectName: file.objectName,
+                            error: file.error,
+                            filePath: file.filePath,
+                            originalQuery: query,
+                            queryIndex: i
+                        })));
+                    }
+                }
+                else {
+                    errors.push({
+                        query: query,
+                        error: result.error,
+                        index: i,
+                        duration: queryDuration
+                    });
+                }
+                // 查询间隔 - 让系统有时间清理资源
+                if (i < queries.length - 1) {
+                    const interval = config?.requestInterval || 1000;
+                    console.error(`等待 ${interval}ms 后处理下一个查询...`);
+                    await new Promise(resolve => setTimeout(resolve, interval));
+                }
+            }
+            catch (error) {
+                const queryDuration = Date.now() - queryStartTime;
+                const errorMessage = `查询 ${query.object_type} - ${query.object_name} 失败: ${error instanceof Error ? error.message : String(error)}`;
+                errors.push({
+                    query: query,
+                    error: errorMessage,
+                    index: i,
+                    duration: queryDuration
+                });
+                console.error(errorMessage);
+                console.error(error);
+            }
+        }
+        const totalDuration = Date.now() - startTime;
+        const avgDuration = totalDuration / queries.length;
+        console.error('\n========================================');
+        console.error(`批量查询完成`);
+        console.error(`总耗时: ${totalDuration}ms`);
+        console.error(`平均耗时: ${avgDuration.toFixed(0)}ms/查询`);
+        console.error(`成功: ${results.length}, 失败: ${errors.length}`);
+        console.error('========================================');
+        // 输出文件错误信息
+        if (fileErrors.length > 0) {
+            console.error(`\n文件错误汇总 (共 ${fileErrors.length} 个):`);
+            console.error('========================');
+            fileErrors.forEach((fileError, index) => {
+                console.error(`${index + 1}. [查询${fileError.queryIndex + 1}] ${fileError.objectType}/${fileError.objectName}`);
+                console.error(`   来源: ${fileError.originalQuery.object_type} - ${fileError.originalQuery.object_name}`);
+                console.error(`   错误: ${fileError.error || '未知错误'}`);
+                if (fileError.filePath) {
+                    console.error(`   路径: ${fileError.filePath}`);
+                }
+            });
+        }
+        // 输出错误详情
+        if (errors.length > 0) {
+            console.error(`\n查询错误详情:`);
+            console.error('========================');
+            errors.forEach((error, index) => {
+                console.error(`${index + 1}. [查询${error.index + 1}] ${error.query.object_type} - ${error.query.object_name}`);
+                console.error(`   耗时: ${error.duration}ms`);
+                console.error(`   错误: ${error.error}`);
+            });
+        }
+        return {
+            success: true,
+            data: {
+                results: results,
+                errors: errors,
+                failed_files: fileErrors,
+                summary: {
+                    total_queries: queries.length,
+                    successful_queries: results.length,
+                    failed_queries: errors.length,
+                    failed_files: fileErrors.length,
+                    success_rate: (results.length / queries.length * 100).toFixed(2) + '%',
+                    total_duration_ms: totalDuration,
+                    average_duration_ms: Math.round(avgDuration)
+                }
+            },
+            message: `批量递归查询完成 - 成功 ${results.length}/${queries.length} 个 (${(results.length / queries.length * 100).toFixed(1)}%)，失败 ${errors.length} 个，文件错误 ${fileErrors.length} 个，总耗时 ${totalDuration}ms`
+        };
+    }
+    catch (error) {
+        const errorMessage = `批量递归查询失败: ${error instanceof Error ? error.message : String(error)}`;
+        console.error(errorMessage);
+        console.error(error);
+        return {
+            success: false,
+            error: errorMessage,
+            data: null
+        };
+    }
+}

package/dist/recursive/recursiveObjectQuery.d.ts

@@ -0,0 +1,159 @@
+import { RecursiveQueryConfig, RecursiveQueryResult } from './recursiveQueryConfig';
+/**
+ * 递归对象查询器
+ * 用于查询ABAP对象及其引用的所有相关对象
+ */
+export declare class RecursiveObjectQuery {
+    private config;
+    private result;
+    private context;
+    private taskQueue;
+    private objectCache;
+    private screenCache;
+    constructor(config?: Partial<RecursiveQueryConfig>);
+    /**
+     * 等待所有任务完成
+     */
+    private waitForAllTasks;
+    /**
+     * 检查对象是否应该被过滤（不进行递归查询）
+     * @param objectType 对象类型
+     * @param objectName 对象名称
+     * @returns true表示应该过滤（不递归），false表示可以递归
+     */
+    private shouldFilterRecursion;
+    /**
+     * 模式匹配（支持通配符 * 和 ?）
+     * @param text 要匹配的文本
+     * @param pattern 模式字符串
+     * @returns 是否匹配
+     */
+    private matchPattern;
+    /**
+     * 执行递归查询（优化版本）
+     * @param objectType 对象类型
+     * @param objectName 对象名称
+     * @returns 查询结果
+     */
+    execute(objectType: string, objectName: string): Promise<RecursiveQueryResult>;
+    /**
+     * 递归处理对象（优化版本）
+     * 采用并发队列 + 缓存机制，提高执行效率
+     * 修复死锁问题：
+     * 1. 避免在任务队列内部进行递归调用
+     * 2. 使用正确的循环引用检测机制
+     * 3. 分离查询和递归处理逻辑
+     */
+    private processObjectRecursively;
+    /**
+     * 处理函数组
+     * 当处理函数时，提取函数组信息并生成函数组文件
+     */
+    private processFunctionGroup;
+    /**
+     * 处理包含文件
+     */
+    private processIncludes;
+    /**
+     * 下载 include 文件并根据内容自动检测类型，添加符合 abaplint 规范的后缀
+     */
+    private downloadIncludeWithTypeDetection;
+    /**
+     * 使用 abaplint 进行精确的语法分析来检测 include 文件类型
+     * 这是最准确的方法，因为它真正解析了 ABAP 语法
+     */
+    private detectIncludeType;
+    /**
+     * 根据 include 类型生成符合 abaplint 规范的文件路径
+     */
+    private generateIncludeFilePath;
+    /**
+     * 处理文本元素
+     * 按照abapGit协议，文本元素应该单独导出为XML文件
+     */
+    private processTextElements;
+    /**
+     * 处理消息
+     * 按照abapGit协议，消息应该使用MSAG XML格式单独导出
+     */
+    private processMessages;
+    /**
+     * 处理GUI标题
+     */
+    private processGuiTitles;
+    /**
+     * 处理结构体
+     */
+    private processStructures;
+    /**
+     * 处理单个结构体
+     */
+    private processSingleStructure;
+    /**
+     * 处理透明表，获取并保存完整表结构信息
+     */
+    private processTransparentTable;
+    /**
+     * 处理结构体字段中的domain定义
+     */
+    private processStructureDomains;
+    /**
+     * 处理单个domain定义
+     */
+    private processSingleDomain;
+    /**
+     * 统一的文件路径生成器 - 根据对象类型和名称生成标准文件路径
+     * 支持多种ABAP对象类型：DOMAIN, STRUCTURE, CLASS, FUNCTION, PROGRAM, INCLUDE
+     */
+    private generateFilePath;
+    /**
+     * 获取ABAP对象类型的默认文件扩展名
+     */
+    private getDefaultExtension;
+    /**
+     * 获取ABAP对象类型的标准目录名
+     */
+    private getObjectDirectory;
+    /**
+     * 下载domain文件
+     */
+    private downloadDomainFile;
+    /**
+     * 下载结构文件
+     */
+    private downloadStructureFile;
+    /**
+     * 通用下载错误处理方法
+     */
+    private handleDownloadError;
+    /**
+     * 从对象数据中提取函数组信息
+     */
+    private extractFunctionGroup;
+    /**
+     * 使用已有的对象数据下载对象源代码（包含正确的函数组信息）
+     */
+    private downloadObjectSourceWithData;
+    /**
+     * 查询对象引用内容（包含下载源代码）
+     * 现在包含下载逻辑，因为需要函数组信息来正确下载函数源代码
+     */
+    private queryObjectReferences;
+    /**
+     * 生成对象键
+     */
+    private generateObjectKey;
+    /**
+     * 延迟函数
+     */
+    private delay;
+    /**
+     * 获取结果摘要
+     */
+    getResultSummary(): string;
+    /**
+     * 获取文件错误详细信息
+     */
+    getFileErrorDetails(): string;
+}
+//# sourceMappingURL=recursiveObjectQuery.d.ts.map

package/dist/recursive/recursiveObjectQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursiveObjectQuery.d.ts","sourceRoot":"","sources":["../../src/recursive/recursiveObjectQuery.ts"],"names":[],"mappings":"AASA,OAAO,EACH,oBAAoB,EAGpB,oBAAoB,EAEvB,MAAM,wBAAwB,CAAC;AAwMhC;;;GAGG;AACH,qBAAa,oBAAoB;IAC7B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,WAAW,CAAc;gBAGrB,MAAM,GAAE,OAAO,CAAC,oBAAoB,CAAM;IAyEtD;;OAEG;YACW,eAAe;IAS7B;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAqD7B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAapB;;;;;OAKG;IACG,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;IA2DpF;;;;;;;OAOG;YACW,wBAAwB;IAkLtC;;;OAGG;YACW,oBAAoB;IAuClC;;OAEG;YACW,eAAe;IAgB7B;;OAEG;YACW,gCAAgC;IAkE9C;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAiFzB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAmC/B;;;OAGG;YACW,mBAAmB;IAiBjC;;;OAGG;YACW,eAAe;IAiB7B;;OAEG;YACW,gBAAgB;IAwC9B;;OAEG;YACW,iBAAiB;IAa/B;;OAEG;YACW,sBAAsB;IA0BpC;;OAEG;YACW,uBAAuB;IAwErC;;OAEG;YACW,uBAAuB;IA2CrC;;OAEG;YACW,mBAAmB;IAyBjC;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAYxB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAY3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAY1B;;OAEG;YACW,kBAAkB;IAyBhC;;OAEG;YACW,qBAAqB;IAwBnC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAc3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAU5B;;OAEG;YACW,4BAA4B;IA8F1C;;;OAGG;YACW,qBAAqB;IAoKnC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACH,OAAO,CAAC,KAAK;IAIb;;OAEG;IACH,gBAAgB,IAAI,MAAM;IAsB1B;;OAEG;IACH,mBAAmB,IAAI,MAAM;CAiBhC"}