abap-adt-api/build/api/debugger.js

Interface to Abap Developer Tools webservice

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.debuggerSetVariableValue = exports.debuggerGoToStackOld = exports.debuggerGoToStack = exports.debuggerStep = exports.debuggerVariables = exports.debuggerChildVariables = exports.simpleDebuggerStack = exports.debuggerStack = exports.debuggerSaveSettings = exports.debuggerAttach = exports.debuggerDeleteBreakpoints = exports.debuggerSetBreakpoints = exports.isDebuggerBreakpoint = exports.debuggerDeleteListener = exports.debuggerListen = exports.debuggerListeners = exports.isDebuggee = exports.isDebugListenerError = exports.debugMetaIsComplex = void 0;
const __1 = require("..");
const utilities_1 = require("../utilities");
const urlparser_1 = require("./urlparser");
const debugMetaIsComplex = (m) => !["simple", "string", "boxedcomp", "anonymcomp", "unknown"].find(e => e === m);
exports.debugMetaIsComplex = debugMetaIsComplex;
const parseStep = (body) => {
    var _a;
    const raw = (0, utilities_1.fullParse)(body, { removeNSPrefix: true });
    checkException(raw);
    const attrs = (0, utilities_1.xmlNodeAttr)(raw.step);
    const settings = (0, utilities_1.xmlNodeAttr)((_a = raw === null || raw === void 0 ? void 0 : raw.step) === null || _a === void 0 ? void 0 : _a.settings);
    const actions = (0, utilities_1.xmlArray)(raw, "step", "actions", "action").map(utilities_1.xmlNodeAttr);
    return { ...attrs, actions, settings };
};
const convertVariable = (v) => ({
    ...v, TABLE_LINES: (0, utilities_1.toInt)(v.TABLE_LINES),
    LENGTH: (0, utilities_1.toInt)(v.LENGTH),
    INHERITANCE_LEVEL: (0, utilities_1.toInt)(v.INHERITANCE_LEVEL),
    VALUE: v.VALUE,
    ID: v.ID,
    NAME: v.NAME
});
const parseVariables = (body) => {
    const raw = (0, utilities_1.fullParse)(body, { removeNSPrefix: true, parseTagValue: false, numberParseOptions: utilities_1.numberParseOptions });
    const variables = (0, utilities_1.xmlArray)(raw, "abap", "values", "DATA", "STPDA_ADT_VARIABLE")
        .map(convertVariable);
    return variables;
};
const parseChildVariables = (body) => {
    const raw = (0, utilities_1.fullParse)(body, { removeNSPrefix: true, parseTagValue: false, numberParseOptions: utilities_1.numberParseOptions });
    const hierarchies = (0, utilities_1.xmlArray)(raw, "abap", "values", "DATA", "HIERARCHIES", "STPDA_ADT_VARIABLE_HIERARCHY");
    const variables = (0, utilities_1.xmlArray)(raw, "abap", "values", "DATA", "VARIABLES", "STPDA_ADT_VARIABLE")
        .map(convertVariable);
    return { hierarchies, variables };
};
const parseStack = (body) => {
    const raw = (0, utilities_1.fullParse)(body, { removeNSPrefix: true });
    const stack = (0, utilities_1.xmlArray)(raw, "stack", "stackEntry")
        .map(utilities_1.xmlNodeAttr)
        .map(x => ({ ...x, uri: (0, urlparser_1.parseUri)(x.uri) }));
    const attrs = (0, utilities_1.xmlNodeAttr)(raw.stack);
    return { ...attrs, stack };
};
const parseDebugSettings = (body) => {
    const raw = (0, utilities_1.fullParse)(body, { removeNSPrefix: true });
    return (0, utilities_1.xmlNodeAttr)(raw.settings);
};
const parseAttach = (body) => {
    const raw = (0, utilities_1.fullParse)(body, { removeNSPrefix: true });
    const attrs = (0, utilities_1.xmlNodeAttr)(raw.attach);
    const reachedBreakpoints = (0, utilities_1.xmlArray)(raw, "attach", "reachedBreakpoints", "breakpoint").map(utilities_1.xmlNodeAttr);
    const actions = (0, utilities_1.xmlArray)(raw, "attach", "actions", "action").map(utilities_1.xmlNodeAttr);
    return { ...attrs, actions, reachedBreakpoints };
};
const parseBreakpoints = (body) => {
    const raw = (0, utilities_1.fullParse)(body, { removeNSPrefix: true });
    return (0, utilities_1.xmlArray)(raw, "breakpoints", "breakpoint")
        .map(utilities_1.xmlNodeAttr)
        .map(x => {
        if (x.uri)
            return { ...x, uri: (0, urlparser_1.parseUri)(x.uri) };
        return x;
    });
};
const parseDebugError = (raw) => {
    if (raw.exception) {
        const { namespace: { "@_id": namespace }, type: { "@_id": type }, localizedMessage, message } = raw.exception;
        const parseMessage = (m) => ({ text: m["#text"], lang: m["@_lang"] });
        const entries = {};
        for (const ex of (0, utilities_1.xmlArray)(raw.exception, "properties", "entry"))
            entries[ex["@_key"]] = ex["#text"];
        return {
            ...entries,
            namespace,
            type,
            message: parseMessage(message),
            localizedMessage: parseMessage(localizedMessage)
        };
    }
};
const checkException = (raw) => {
    const e = parseDebugError(raw);
    if (e) {
        const err = new Error(e.message.text);
        err.extra = e;
        throw err;
    }
};
const isDebugListenerError = (e) => !!e && "conflictText" in e && "com.sap.adt.communicationFramework.subType" in e;
exports.isDebugListenerError = isDebugListenerError;
const isDebuggee = (d) => !!d && !["CLIENT", "DEBUGGEE_ID", "TERMINAL_ID", "IDE_ID", "DEBUGGEE_USER"].find(f => !(f in d));
exports.isDebuggee = isDebuggee;
const parseDebugListeners = (body) => {
    if (!body)
        return;
    const raw = (0, utilities_1.fullParse)(body, { removeNSPrefix: true });
    const err = parseDebugError(raw);
    if (err)
        return err;
    const debug = (0, utilities_1.xmlNode)(raw, "abap", "values", "DATA", "STPDA_DEBUGGEE");
    return { ...debug, URI: (0, urlparser_1.parseUri)(debug.URI) };
};
async function debuggerListeners(h, debuggingMode, terminalId, ideId, requestUser, checkConflict = true) {
    const qs = {
        debuggingMode,
        requestUser,
        terminalId,
        ideId,
        checkConflict
    };
    const response = await h.request("/sap/bc/adt/debugger/listeners", { qs });
    if (!response.body)
        return;
    const raw = (0, utilities_1.fullParse)(response.body, { removeNSPrefix: true });
    return parseDebugError(raw);
}
exports.debuggerListeners = debuggerListeners;
async function debuggerListen(h, debuggingMode, terminalId, ideId, requestUser, checkConflict = true, isNotifiedOnConflict = true) {
    const qs = {
        debuggingMode,
        requestUser,
        terminalId,
        ideId,
        checkConflict,
        isNotifiedOnConflict
    };
    const response = await h.request("/sap/bc/adt/debugger/listeners", {
        method: "POST",
        timeout: 360000000,
        qs
    });
    return parseDebugListeners(response.body);
}
exports.debuggerListen = debuggerListen;
async function debuggerDeleteListener(h, debuggingMode, terminalId, ideId, requestUser) {
    const qs = {
        debuggingMode,
        requestUser,
        terminalId,
        ideId,
        checkConflict: false,
        notifyConflict: true
    };
    await h.request("/sap/bc/adt/debugger/listeners", { method: "DELETE", qs });
}
exports.debuggerDeleteListener = debuggerDeleteListener;
const formatBreakpoint = (clientId) => (b) => {
    if ((0, utilities_1.isString)(b))
        return `<breakpoint xmlns:adtcore="http://www.sap.com/adt/core" kind="line" clientId="${clientId}" skipCount="0" adtcore:uri="${b}"/>`;
    const uri = `adtcore:uri="${b.uri.uri}#start=${b.uri.range.start.line}"`;
    const condition = b.condition ? `condition="${b.condition}"` : ``;
    return `<breakpoint xmlns:adtcore="http://www.sap.com/adt/core" kind="${b.kind}" clientId="${b.clientId}" skipCount="0" ${uri} ${condition}/>`;
};
const isDebuggerBreakpoint = (x) => "uri" in x;
exports.isDebuggerBreakpoint = isDebuggerBreakpoint;
async function debuggerSetBreakpoints(h, debuggingMode, terminalId, ideId, clientId, breakpoints, requestUser, scope = "external", systemDebugging = false, deactivated = false, syncScopeUri = "") {
    const syncScope = syncScopeUri ?
        `<syncScope mode="partial"><adtcore:objectReference xmlns:adtcore="http://www.sap.com/adt/core" adtcore:uri="${syncScopeUri}"/></syncScope>`
        : `<syncScope mode="full"></syncScope>`;
    const body = `<?xml version="1.0" encoding="UTF-8"?>
    <dbg:breakpoints scope="${scope}" debuggingMode="${debuggingMode}" requestUser="${requestUser}" 
        terminalId="${terminalId}" ideId="${ideId}" systemDebugging="${systemDebugging}" deactivated="${deactivated}"
        xmlns:dbg="http://www.sap.com/adt/debugger">
        ${syncScope}
        ${breakpoints.map(formatBreakpoint(clientId)).join("")}
    </dbg:breakpoints>`;
    const headers = {
        "Content-Type": "application/xml",
        Accept: "application/xml"
    };
    const response = await h.request("/sap/bc/adt/debugger/breakpoints", {
        method: "POST",
        headers,
        body
    });
    return parseBreakpoints(response.body);
}
exports.debuggerSetBreakpoints = debuggerSetBreakpoints;
async function debuggerDeleteBreakpoints(h, breakpoint, debuggingMode, terminalId, ideId, requestUser, scope = "external") {
    const headers = { Accept: "application/xml" };
    const qs = { scope, debuggingMode, requestUser, terminalId, ideId };
    await h.request(`/sap/bc/adt/debugger/breakpoints/${encodeURIComponent(breakpoint.id)}`, {
        method: "DELETE",
        headers,
        qs
    });
}
exports.debuggerDeleteBreakpoints = debuggerDeleteBreakpoints;
async function debuggerAttach(h, debuggingMode, debuggeeId, requestUser = "", dynproDebugging = true) {
    const headers = {
        Accept: "application/xml"
    };
    const qs = {
        method: "attach",
        debuggeeId,
        dynproDebugging,
        debuggingMode,
        requestUser
    };
    const response = await h.request("/sap/bc/adt/debugger", {
        method: "POST",
        headers,
        qs
    });
    return parseAttach(response.body);
}
exports.debuggerAttach = debuggerAttach;
async function debuggerSaveSettings(h, settings) {
    const headers = {
        "Content-Type": "application/xml",
        Accept: "application/xml"
    };
    const { systemDebugging = false, createExceptionObject = false, backgroundRFC = false, sharedObjectDebugging = false, showDataAging = true, updateDebugging = false } = settings;
    const body = `<?xml version="1.0" encoding="UTF-8"?>
    <dbg:settings xmlns:dbg="http://www.sap.com/adt/debugger" 
    systemDebugging="${systemDebugging}" createExceptionObject="${createExceptionObject}" 
    backgroundRFC="${backgroundRFC}" sharedObjectDebugging="${sharedObjectDebugging}" 
    showDataAging="${showDataAging}" updateDebugging="${updateDebugging}">
    </dbg:settings>`;
    const qs = { method: "setDebuggerSettings" };
    const response = await h.request("/sap/bc/adt/debugger", {
        method: "POST",
        headers,
        body,
        qs
    });
    return parseDebugSettings(response.body);
}
exports.debuggerSaveSettings = debuggerSaveSettings;
async function debuggerStack(h, semanticURIs = true) {
    const headers = { Accept: "application/xml" };
    const qs = { method: "getStack", emode: "_", semanticURIs };
    const response = await h.request("/sap/bc/adt/debugger/stack", {
        headers,
        qs
    });
    return parseStack(response.body);
}
exports.debuggerStack = debuggerStack;
async function simpleDebuggerStack(h, semanticURIs = true) {
    const headers = { Accept: "application/xml" };
    const qs = { method: "getStack", emode: "_", semanticURIs };
    const response = await h.request("/sap/bc/adt/debugger", { headers, method: "POST", qs });
    return parseStack(response.body);
}
exports.simpleDebuggerStack = simpleDebuggerStack;
async function debuggerChildVariables(h, parents = ["@ROOT", "@DATAAGING"]) {
    const headers = {
        Accept: "application/vnd.sap.as+xml;charset=UTF-8;dataname=com.sap.adt.debugger.ChildVariables",
        "Content-Type": "application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.debugger.ChildVariables"
    };
    const hierarchies = parents.map(p => `<STPDA_ADT_VARIABLE_HIERARCHY><PARENT_ID>${(0, utilities_1.encodeEntity)(p)}</PARENT_ID></STPDA_ADT_VARIABLE_HIERARCHY>`);
    const body = `<?xml version="1.0" encoding="UTF-8" ?><asx:abap version="1.0" xmlns:asx="http://www.sap.com/abapxml"><asx:values><DATA>
    <HIERARCHIES>${hierarchies.join("")}</HIERARCHIES>
    </DATA></asx:values></asx:abap>`;
    const qs = { method: "getChildVariables" };
    const response = await h.request("/sap/bc/adt/debugger", { method: "POST", headers, qs, body });
    return parseChildVariables(response.body);
}
exports.debuggerChildVariables = debuggerChildVariables;
async function debuggerVariables(h, parents) {
    const headers = {
        Accept: "application/vnd.sap.as+xml;charset=UTF-8;dataname=com.sap.adt.debugger.Variables",
        "Content-Type": "application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.debugger.Variables"
    };
    const mainBody = parents.map(p => `<STPDA_ADT_VARIABLE><ID>${(0, utilities_1.encodeEntity)(p)}</ID></STPDA_ADT_VARIABLE>`).join("");
    const body = `<?xml version="1.0" encoding="UTF-8" ?><asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0"><asx:values>
    <DATA>${mainBody}</DATA></asx:values></asx:abap>`;
    const qs = { method: "getVariables" };
    const response = await h.request("/sap/bc/adt/debugger", { method: "POST", headers, qs, body });
    return parseVariables(response.body);
}
exports.debuggerVariables = debuggerVariables;
async function debuggerStep(h, method, uri) {
    const headers = { Accept: "application/xml" };
    const response = await h.request("/sap/bc/adt/debugger", { method: "POST", headers, qs: { method, uri } });
    return parseStep(response.body);
}
exports.debuggerStep = debuggerStep;
async function debuggerGoToStack(h, stackUri) {
    if (!stackUri.match(/^\/sap\/bc\/adt\/debugger\/stack\/type\/[\w]+\/position\/\d+$/))
        throw (0, __1.adtException)(`Invalid stack URL: ${stackUri}`);
    await h.request(stackUri, { method: "PUT" });
}
exports.debuggerGoToStack = debuggerGoToStack;
async function debuggerGoToStackOld(h, position) {
    const qs = { method: "setStackPosition", position };
    await h.request(`/sap/bc/adt/debugger`, { method: "POST", qs });
}
exports.debuggerGoToStackOld = debuggerGoToStackOld;
async function debuggerSetVariableValue(h, variableName, value) {
    const qs = { variableName };
    const resp = await h.request(`/sap/bc/adt/debugger?method=setVariableValue`, { method: "POST", qs, body: value });
    return resp.body;
}
exports.debuggerSetVariableValue = debuggerSetVariableValue;