@mcp-abap-adt/core 2.5.2 → 2.7.0

package/dist/handlers/table/handleGetTableContents.js

@@ -1,387 +0,0 @@
-"use strict";
-/**
- * SAP ADT Data Preview API Implementation - COMPLETED
- *
- * TASK: Fix the SAP ADT data preview API implementation for getting table contents.
- * The task involved correcting the POST request format to match Eclipse ADT behavior,
- * which sends SQL SELECT statements with explicit field lists instead of "SELECT *" queries.
- *
- * COMPLETED FIXES:
- * ✅ Fixed makeAdtRequest function to use POST instead of GET for table contents
- * ✅ Added Content-Type "text/plain; charset=utf-8" for SQL queries
- * ✅ Improved cleanup() function in utils.ts to properly clear axios interceptors
- * ✅ Updated Jest configuration with forceExit and increased timeouts
- * ✅ Added comprehensive logging to handleGetTableContents for debugging
- * ✅ Fixed CDS field parsing to correctly extract field names from "define table" syntax
- * ✅ Generate proper SQL SELECT statements with explicit field lists for any table
- * ✅ Tested with T000, T100S, and TOBJ tables - all working successfully
- * ✅ Added test to verify generated SQL matches expected format
- *
- * IMPLEMENTATION DETAILS:
- * - CDS field parsing using line-by-line regex matching for field definitions
- * - SQL generation with table-prefixed field names (e.g., "T000~MANDT")
- * - Fallback mechanisms for different table structure formats
- * - Proper error handling and logging throughout the process
- * - All 19 tests passing including new SQL format validation test
- *
- * The implementation now correctly sends SQL SELECT statements like:
- * "SELECT T000~MANDT, T000~MTEXT, T000~ORT01, T000~MWAER, T000~ADRNR, ... FROM T000"
- * instead of "SELECT * FROM T000" which SAP ADT doesn't support.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleGetTableContents = handleGetTableContents;
-const utils_1 = require("../../lib/utils");
-const utils_2 = require("../../lib/utils");
-const index_1 = require("../../index");
-const writeResultToFile_1 = require("../../lib/writeResultToFile");
-exports.TOOL_DEFINITION = {
-    "name": "GetTableContents",
-    "description": "Retrieve contents of an ABAP table.",
-    "inputSchema": {
-        "type": "object",
-        "properties": {
-            "table_name": {
-                "type": "string",
-                "description": "Name of the ABAP table"
-            },
-            "max_rows": {
-                "type": "number",
-                "description": "Maximum number of rows to retrieve",
-                "default": 100
-            }
-        },
-        "required": [
-            "table_name"
-        ]
-    }
-};
-/**
- * Parse SAP ADT XML response and convert to JSON format with rows
- */
-function parseTableDataXml(xmlData, tableName) {
-    try {
-        // Extract basic information
-        const totalRowsMatch = xmlData.match(/<dataPreview:totalRows>(\d+)<\/dataPreview:totalRows>/);
-        const totalRows = totalRowsMatch ? parseInt(totalRowsMatch[1]) : 0;
-        const queryTimeMatch = xmlData.match(/<dataPreview:queryExecutionTime>([\d.]+)<\/dataPreview:queryExecutionTime>/);
-        const queryExecutionTime = queryTimeMatch ? parseFloat(queryTimeMatch[1]) : 0;
-        // Extract column metadata
-        const columns = [];
-        const columnMatches = xmlData.match(/<dataPreview:metadata[^>]*>/g);
-        if (columnMatches) {
-            columnMatches.forEach(match => {
-                const nameMatch = match.match(/dataPreview:name="([^"]+)"/);
-                const typeMatch = match.match(/dataPreview:type="([^"]+)"/);
-                const descMatch = match.match(/dataPreview:description="([^"]+)"/);
-                const lengthMatch = match.match(/dataPreview:length="(\d+)"/);
-                if (nameMatch) {
-                    columns.push({
-                        name: nameMatch[1],
-                        type: typeMatch ? typeMatch[1] : 'UNKNOWN',
-                        description: descMatch ? descMatch[1] : '',
-                        length: lengthMatch ? parseInt(lengthMatch[1]) : undefined
-                    });
-                }
-            });
-        }
-        // Extract row data - each column has its own dataSet with multiple data elements
-        const rows = [];
-        // Find all column sections
-        const columnSections = xmlData.match(/<dataPreview:columns>.*?<\/dataPreview:columns>/gs);
-        if (columnSections && columnSections.length > 0) {
-            // Extract data for each column
-            const columnData = {};
-            columnSections.forEach((section, index) => {
-                if (index < columns.length) {
-                    const columnName = columns[index].name;
-                    const dataMatches = section.match(/<dataPreview:data[^>]*>(.*?)<\/dataPreview:data>/g);
-                    if (dataMatches) {
-                        columnData[columnName] = dataMatches.map(match => {
-                            const content = match.replace(/<[^>]+>/g, '');
-                            return content || null;
-                        });
-                    }
-                    else {
-                        columnData[columnName] = [];
-                    }
-                }
-            });
-            // Convert column-based data to row-based data
-            const maxRowCount = Math.max(...Object.values(columnData).map(arr => arr.length), 0);
-            for (let rowIndex = 0; rowIndex < maxRowCount; rowIndex++) {
-                const row = {};
-                columns.forEach(column => {
-                    const columnValues = columnData[column.name] || [];
-                    row[column.name] = columnValues[rowIndex] || null;
-                });
-                rows.push(row);
-            }
-        }
-        return {
-            tableName,
-            totalRows,
-            queryExecutionTime,
-            columns,
-            rows,
-            metadata: {
-                recordCount: rows.length,
-                columnCount: columns.length
-            }
-        };
-    }
-    catch (error) {
-        utils_1.logger.error('Error parsing table data XML', { error: error instanceof Error ? error.message : String(error) });
-        // Return basic structure on parse error
-        return {
-            tableName,
-            totalRows: 0,
-            queryExecutionTime: 0,
-            columns: [],
-            rows: [],
-            metadata: {
-                recordCount: 0,
-                columnCount: 0
-            },
-            error: 'Failed to parse XML response'
-        };
-    }
-}
-// ABAP table source may contain statements such as "INCLUDE STRUCTURE" that
-// are not real fields, so we maintain an explicit deny-list to avoid injecting
-// pseudo identifiers into the SQL statement sent to SAP.
-const STRUCTURE_KEYWORDS = new Set([
-    'INCLUDE',
-    'APPEND',
-    'BEGIN',
-    'END',
-    'FOREIGN',
-    'PRIMARY',
-    'INDEX',
-    'UNIQUE',
-    'CHECK',
-    'CONSTRAINT',
-    'KEY'
-]);
-async function getFieldsFromDatapreviewMetadata(tableName) {
-    try {
-        const metadataUrl = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/datapreview/ddic/${(0, utils_2.encodeSapObjectName)(tableName)}/metadata`;
-        utils_1.logger.info('Fetching datapreview metadata', { metadataUrl });
-        const metadataResponse = await (0, utils_2.makeAdtRequestWithTimeout)(metadataUrl, 'GET', 'default');
-        const xmlText = metadataResponse.data;
-        const fieldMatches = xmlText.match(/<dataPreview:metadata[^>]*dataPreview:name="([^"]+)"[^>]*>/gi);
-        if (!fieldMatches) {
-            return [];
-        }
-        const fields = fieldMatches
-            .map((match) => {
-            const fieldNameMatch = match.match(/dataPreview:name="([^"]+)"/i);
-            const fieldName = fieldNameMatch?.[1]?.toUpperCase();
-            if (!fieldName || STRUCTURE_KEYWORDS.has(fieldName)) {
-                return '';
-            }
-            if (!/^[A-Z0-9_\/]+$/.test(fieldName)) {
-                return '';
-            }
-            return `${tableName}~${fieldName}`;
-        })
-            .filter((field) => field !== '');
-        return Array.from(new Set(fields));
-    }
-    catch (error) {
-        utils_1.logger.warn('Failed to fetch datapreview metadata', {
-            error: error instanceof Error ? error.message : String(error),
-            tableName
-        });
-        return [];
-    }
-}
-async function handleGetTableContents(args) {
-    try {
-        utils_1.logger.info('handleGetTableContents called', { args });
-        if (!args?.table_name) {
-            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Table name is required');
-        }
-        const maxRows = args.max_rows || 100;
-        const tableName = args.table_name;
-        // Detect deployment type by authentication method. JWT ~= cloud (BTP) where
-        // direct table datapreview access is restricted. Basic auth typically
-        // indicates on-premise systems where ADT datapreview may work.
-        try {
-            const cfg = (0, index_1.getConfig)();
-            if (cfg.authType === 'jwt') {
-                utils_1.logger.warn('handleGetTableContents blocked on cloud deployment (JWT auth)', { tableName });
-                return {
-                    isError: true,
-                    content: [
-                        {
-                            type: 'text',
-                            text: 'Forbidden: Direct table contents preview via ADT is not permitted on cloud ABAP (BTP) when using JWT authentication. Use an on-premise system or another API that exposes data, or run this tool against a system with basic auth.'
-                        }
-                    ]
-                };
-            }
-        }
-        catch (cfgErr) {
-            // If config cannot be determined, proceed with normal flow but log it.
-            utils_1.logger.warn('Could not determine SAP config for deployment detection', { error: cfgErr instanceof Error ? cfgErr.message : String(cfgErr) });
-        }
-        utils_1.logger.info('Making table contents request', { tableName, maxRows });
-        // First, get the table structure to know all fields
-        const tableStructureUrl = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/ddic/tables/${(0, utils_2.encodeSapObjectName)(tableName)}/source/main`;
-        utils_1.logger.info('Getting table structure first', { tableStructureUrl });
-        let tableFields = await getFieldsFromDatapreviewMetadata(tableName);
-        try {
-            if (tableFields.length > 0) {
-                utils_1.logger.info('Using fields from datapreview metadata', { count: tableFields.length, fields: tableFields.slice(0, 5) });
-            }
-            if (tableFields.length === 0) {
-                const structureResponse = await (0, utils_2.makeAdtRequestWithTimeout)(tableStructureUrl, 'GET', 'default');
-                // Parse table structure to extract field names
-                const structureText = structureResponse.data;
-                // Extract field names from ABAP table definition
-                // Support both old and new CDS view syntax
-                const fieldNames = new Set();
-                // Check if this is a CDS view (contains "define table")
-                if (structureText.includes('define table')) {
-                    // New CDS syntax: parse line by line to properly handle field definitions
-                    const lines = structureText.split('\n');
-                    for (const line of lines) {
-                        const trimmedLine = line.trim();
-                        // Match field definitions inside the CDS table definition
-                        const fieldMatch = trimmedLine.match(/^(key\s+)?([a-z0-9_]+)\s*:\s*[a-z0-9_]+/i);
-                        if (fieldMatch) {
-                            const fieldName = fieldMatch[2].trim().toUpperCase();
-                            if (fieldName && fieldName.length > 0) {
-                                fieldNames.add(fieldName);
-                            }
-                        }
-                    }
-                    utils_1.logger.info('Parsed CDS view fields', { count: fieldNames.size, fields: Array.from(fieldNames).slice(0, 10) });
-                }
-                else {
-                    // Old ABAP syntax patterns
-                    const patterns = [
-                        /^\s+([A-Z0-9_]+)\s*:\s*(TYPE|LIKE)/gmi, // FIELD : TYPE pattern
-                        /^\s+([A-Z0-9_]+)\s+(TYPE|LIKE)/gmi, // FIELD TYPE pattern
-                        /^\s+([A-Z0-9_]+)\s*:\s*[A-Z0-9_]+/gmi, // FIELD : DOMAIN pattern
-                        /^\s+([A-Z0-9_]+)\s+[A-Z0-9_]+(?:\([0-9]+\))?/gmi // FIELD DOMAIN(LENGTH) pattern
-                    ];
-                    for (const pattern of patterns) {
-                        const matches = structureText.match(pattern);
-                        if (matches) {
-                            matches.forEach((match) => {
-                                const fieldName = match.trim().split(/[\s:]+/)[0].trim();
-                                if (fieldName && fieldName.length > 0 && !fieldName.includes('.')) {
-                                    fieldNames.add(fieldName);
-                                }
-                            });
-                        }
-                    }
-                    utils_1.logger.info('Parsed traditional ABAP fields', { count: fieldNames.size, fields: Array.from(fieldNames).slice(0, 10) });
-                }
-                if (fieldNames.size > 0) {
-                    tableFields = Array.from(fieldNames)
-                        .filter((fieldName) => {
-                        const upper = fieldName.toUpperCase();
-                        if (STRUCTURE_KEYWORDS.has(upper)) {
-                            return false;
-                        }
-                        return /^[A-Z0-9_\/]+$/.test(upper);
-                    })
-                        .map((fieldName) => `${tableName}~${fieldName}`);
-                }
-                utils_1.logger.info('Extracted table fields', { count: tableFields.length, fields: tableFields.slice(0, 5) });
-            }
-        }
-        catch (structureError) {
-            utils_1.logger.warn('Could not get table structure, falling back to alternative method', {
-                error: structureError instanceof Error ? structureError.message : String(structureError)
-            });
-            // If we can't get structure from main source, try alternative endpoints
-            try {
-                // Try getting table metadata via different endpoint
-                const metadataUrl = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/ddic/tables/${(0, utils_2.encodeSapObjectName)(tableName)}`;
-                const metadataResponse = await (0, utils_2.makeAdtRequestWithTimeout)(metadataUrl, 'GET', 'default');
-                // Parse XML metadata to extract field names
-                const xmlText = metadataResponse.data;
-                const fieldMatches = xmlText.match(/<ddic:field[^>]*name="([^"]+)"/gi);
-                if (fieldMatches) {
-                    tableFields = fieldMatches
-                        .map((match) => {
-                        const fieldName = match.match(/name="([^"]+)"/);
-                        const nameValue = fieldName?.[1];
-                        if (!nameValue) {
-                            return '';
-                        }
-                        if (STRUCTURE_KEYWORDS.has(nameValue.toUpperCase())) {
-                            return '';
-                        }
-                        return `${tableName}~${nameValue}`;
-                    })
-                        .filter(field => field !== '');
-                    utils_1.logger.info('Extracted fields from metadata', { count: tableFields.length, fields: tableFields.slice(0, 5) });
-                }
-            }
-            catch (metadataError) {
-                utils_1.logger.warn('Could not get table metadata either, using generic approach', {
-                    error: metadataError instanceof Error ? metadataError.message : String(metadataError)
-                });
-                // Last resort: use SELECT * but this might not work with SAP ADT
-                // In real implementation, you might want to maintain a cache of known table structures
-                tableFields = [`*`];
-            }
-        }
-        // Always generate SELECT statement with explicit field list when possible
-        let selectStatement;
-        if (tableFields.length > 0 && !tableFields.includes('*')) {
-            selectStatement = `SELECT ${tableFields.join(', ')} FROM ${tableName}`;
-        }
-        else {
-            // Fallback: try with SELECT * (might not work but worth trying)
-            selectStatement = `SELECT * FROM ${tableName}`;
-            utils_1.logger.warn('Using SELECT * as fallback - this might not work with SAP ADT', { tableName });
-        }
-        utils_1.logger.info('Making request with SQL payload', { selectStatement });
-        // Use ADT data preview service to get table contents
-        const url = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/datapreview/ddic?rowNumber=${maxRows}&ddicEntityName=${(0, utils_2.encodeSapObjectName)(tableName)}`;
-        const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'POST', 'long', selectStatement);
-        utils_1.logger.info('Table contents request completed', { status: response.status });
-        // Parse XML response and convert to JSON format with rows
-        const xmlData = response.data;
-        const parsedData = parseTableDataXml(xmlData, tableName);
-        utils_1.logger.info('Parsed table data', {
-            totalRows: parsedData.totalRows,
-            columnsCount: parsedData.columns.length,
-            rowsCount: parsedData.rows.length
-        });
-        const result = {
-            isError: false,
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(parsedData, null, 2)
-                }
-            ]
-        };
-        if (args.filePath) {
-            (0, writeResultToFile_1.writeResultToFile)(JSON.stringify(result, null, 2), args.filePath);
-        }
-        return result;
-    }
-    catch (error) {
-        utils_1.logger.error('Error in handleGetTableContents', {
-            error: error instanceof Error ? error.message : String(error),
-            tableName: args?.table_name
-        });
-        return {
-            isError: true,
-            content: [
-                {
-                    type: "text",
-                    text: error instanceof Error ? error.message : String(error)
-                }
-            ]
-        };
-    }
-}

package/dist/handlers/table/handleValidateTable.d.ts

@@ -1,53 +0,0 @@
-/**
- * ValidateTable Handler - Validate ABAP table name via ADT API
- *
- * Uses validateTableName from @mcp-abap-adt/adt-clients/core/table for table-specific validation.
- */
-export declare const TOOL_DEFINITION: {
-    readonly name: "ValidateTable";
-    readonly description: "Validate an ABAP table name before creation. Checks if the name is valid and available. Can use session_id and session_state from GetSession to maintain the same session.";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly table_name: {
-                readonly type: "string";
-                readonly description: "Table name to validate (e.g., Z_MY_TABLE)";
-            };
-            readonly description: {
-                readonly type: "string";
-                readonly description: "Optional description for validation";
-            };
-            readonly session_id: {
-                readonly type: "string";
-                readonly description: "Session ID from GetSession. If not provided, a new session will be created.";
-            };
-            readonly session_state: {
-                readonly type: "object";
-                readonly description: "Session state from GetSession (cookies, csrf_token, cookie_store). Required if session_id is provided.";
-                readonly properties: {
-                    readonly cookies: {
-                        readonly type: "string";
-                    };
-                    readonly csrf_token: {
-                        readonly type: "string";
-                    };
-                    readonly cookie_store: {
-                        readonly type: "object";
-                    };
-                };
-            };
-        };
-        readonly required: readonly ["table_name"];
-    };
-};
-/**
- * Main handler for ValidateTable MCP tool
- */
-export declare function handleValidateTable(args: any): Promise<{
-    isError: boolean;
-    content: {
-        type: string;
-        text: any;
-    }[];
-}>;
-//# sourceMappingURL=handleValidateTable.d.ts.map

package/dist/handlers/table/handleValidateTable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleValidateTable.d.ts","sourceRoot":"","sources":["../../../src/handlers/table/handleValidateTable.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BlB,CAAC;AAaX;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,GAAG;;;;;;GA8FlD"}

package/dist/handlers/table/handleValidateTable.js

@@ -1,125 +0,0 @@
-"use strict";
-/**
- * ValidateTable Handler - Validate ABAP table name via ADT API
- *
- * Uses validateTableName from @mcp-abap-adt/adt-clients/core/table for table-specific validation.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_DEFINITION = void 0;
-exports.handleValidateTable = handleValidateTable;
-const utils_1 = require("../../lib/utils");
-const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
-exports.TOOL_DEFINITION = {
-    name: "ValidateTable",
-    description: "Validate an ABAP table name before creation. Checks if the name is valid and available. Can use session_id and session_state from GetSession to maintain the same session.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            table_name: {
-                type: "string",
-                description: "Table name to validate (e.g., Z_MY_TABLE)"
-            },
-            description: {
-                type: "string",
-                description: "Optional description for validation"
-            },
-            session_id: {
-                type: "string",
-                description: "Session ID from GetSession. If not provided, a new session will be created."
-            },
-            session_state: {
-                type: "object",
-                description: "Session state from GetSession (cookies, csrf_token, cookie_store). Required if session_id is provided.",
-                properties: {
-                    cookies: { type: "string" },
-                    csrf_token: { type: "string" },
-                    cookie_store: { type: "object" }
-                }
-            }
-        },
-        required: ["table_name"]
-    }
-};
-/**
- * Main handler for ValidateTable MCP tool
- */
-async function handleValidateTable(args) {
-    try {
-        const { table_name, description, session_id, session_state } = args;
-        if (!table_name) {
-            return (0, utils_1.return_error)(new Error('table_name is required'));
-        }
-        const connection = (0, utils_1.getManagedConnection)();
-        // Restore session state if provided
-        if (session_id && session_state) {
-            connection.setSessionState({
-                cookies: session_state.cookies || null,
-                csrfToken: session_state.csrf_token || null,
-                cookieStore: session_state.cookie_store || {}
-            });
-        }
-        else {
-            // Ensure connection is established
-            await connection.connect();
-        }
-        const tableName = table_name.toUpperCase();
-        utils_1.logger.info(`Starting table validation: ${tableName}`);
-        try {
-            const client = new adt_clients_1.CrudClient(connection);
-            await client.validateTable(tableName);
-            const result = client.getValidationResult();
-            if (!result) {
-                throw new Error('Validation did not return a result');
-            }
-            // Get updated session state after validation
-            const updatedSessionState = connection.getSessionState();
-            utils_1.logger.info(`✅ ValidateTable completed: ${tableName}`);
-            utils_1.logger.info(`   Valid: ${result.valid}, Message: ${result.message || 'N/A'}`);
-            return (0, utils_1.return_response)({
-                data: JSON.stringify({
-                    success: result.valid,
-                    table_name: tableName,
-                    description: description || null,
-                    validation_result: result,
-                    session_id: session_id || null,
-                    session_state: updatedSessionState ? {
-                        cookies: updatedSessionState.cookies,
-                        csrf_token: updatedSessionState.csrfToken,
-                        cookie_store: updatedSessionState.cookieStore
-                    } : null,
-                    message: result.valid
-                        ? `Table name ${tableName} is valid and available`
-                        : `Table name ${tableName} validation failed: ${result.message || 'Unknown error'}`
-                }, null, 2)
-            });
-        }
-        catch (error) {
-            utils_1.logger.error(`Error validating table ${tableName}:`, error);
-            let errorMessage = `Failed to validate table: ${error.message || String(error)}`;
-            if (error.response?.status === 404) {
-                errorMessage = `Table ${tableName} not found.`;
-            }
-            else if (error.response?.data && typeof error.response.data === 'string') {
-                try {
-                    const { XMLParser } = require('fast-xml-parser');
-                    const parser = new XMLParser({
-                        ignoreAttributes: false,
-                        attributeNamePrefix: '@_'
-                    });
-                    const errorData = parser.parse(error.response.data);
-                    const errorMsg = errorData['exc:exception']?.message?.['#text'] || errorData['exc:exception']?.message;
-                    if (errorMsg) {
-                        errorMessage = `SAP Error: ${errorMsg}`;
-                    }
-                }
-                catch (parseError) {
-                    // Ignore parse errors
-                }
-            }
-            return (0, utils_1.return_error)(new Error(errorMessage));
-        }
-    }
-    catch (error) {
-        return (0, utils_1.return_error)(error);
-    }
-}

package/dist/handlers/table/readonly/handleGetTable.d.ts

@@ -1,20 +0,0 @@
-import * as z from 'zod';
-export declare const TOOL_DEFINITION: {
-    readonly name: "GetTable";
-    readonly description: "[read-only] Retrieve ABAP table structure.";
-    readonly inputSchema: {
-        readonly table_name: z.ZodString;
-    };
-};
-interface GetTableArgs {
-    [key: string]: any;
-}
-export declare function handleGetTable(args: GetTableArgs): Promise<{
-    isError: boolean;
-    content: {
-        type: string;
-        text: any;
-    }[];
-}>;
-export {};
-//# sourceMappingURL=handleGetTable.d.ts.map

package/dist/handlers/table/readonly/handleGetTable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleGetTable.d.ts","sourceRoot":"","sources":["../../../../src/handlers/table/readonly/handleGetTable.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,eAAe;;;;;;CAMlB,CAAC;AAEX,UAAU,YAAY;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAwCD,wBAAsB,cAAc,CAAC,IAAI,EAAE,YAAY;;;;;;GAsDtD"}