@rayutek/abap-adt-api 6.2.1-pkg-1.0.0

package/build/api/refactor.js

@@ -0,0 +1,470 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMethodExecute = exports.extractMethodPreview = exports.extractMethodEvaluate = exports.renameExecute = exports.renamePreview = exports.changePackageExecute = exports.changePackagePreview = exports.renameEvaluate = exports.fixEdits = exports.fixProposals = void 0;
+const html_entities_1 = require("html-entities");
+const _1 = require(".");
+const AdtException_1 = require("../AdtException");
+const utilities_1 = require("../utilities");
+const urlparser_1 = require("./urlparser");
+async function fixProposals(h, uri, body, line, column) {
+    const qs = { uri: `${uri}#start=${line},${column}` };
+    const headers = { "Content-Type": "application/*", Accept: "application/*" };
+    const response = await h.request("/sap/bc/adt/quickfixes/evaluation", {
+        method: "POST",
+        qs,
+        headers,
+        body
+    });
+    const raw = (0, utilities_1.fullParse)(response.body, { processEntities: false });
+    const rawResults = (0, utilities_1.xmlArray)(raw, "qf:evaluationResults", "evaluationResult");
+    return rawResults.map(x => {
+        const attrs = (0, utilities_1.xmlNodeAttr)((0, utilities_1.xmlNode)(x, "adtcore:objectReference"));
+        const userContent = (0, html_entities_1.decode)((0, utilities_1.xmlNode)(x, "userContent") || "");
+        return {
+            ...attrs,
+            "adtcore:name": attrs["adtcore:name"],
+            "adtcore:description": attrs["adtcore:description"],
+            uri,
+            line,
+            column,
+            userContent
+        };
+    });
+}
+exports.fixProposals = fixProposals;
+async function fixEdits(h, proposal, source) {
+    if (!proposal["adtcore:uri"].match(/\/sap\/bc\/adt\/quickfixes/))
+        throw (0, AdtException_1.adtException)("Invalid fix proposal");
+    const body = `<?xml version="1.0" encoding="UTF-8"?>
+  <quickfixes:proposalRequest xmlns:quickfixes="http://www.sap.com/adt/quickfixes"
+     xmlns:adtcore="http://www.sap.com/adt/core">
+    <input>
+      <content>${(0, utilities_1.encodeEntity)(source)}</content>
+      <adtcore:objectReference adtcore:uri="${proposal.uri}#start=${proposal.line},${proposal.column}"/>
+    </input>
+    <userContent>${(0, utilities_1.encodeEntity)(proposal.userContent)}</userContent>
+  </quickfixes:proposalRequest>`;
+    const headers = { "Content-Type": "application/*", Accept: "application/*" };
+    const response = await h.request(proposal["adtcore:uri"], {
+        method: "POST",
+        headers,
+        body
+    });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    const parseDelta = (d) => {
+        const attr = (0, utilities_1.xmlNodeAttr)((0, utilities_1.xmlNode)(d, "adtcore:objectReference"));
+        const content = d.content;
+        const { uri, range } = (0, urlparser_1.parseUri)(attr["adtcore:uri"]);
+        return {
+            uri,
+            range,
+            name: attr["adtcore:name"],
+            type: attr["adtcore:type"],
+            content
+        };
+    };
+    const deltas = (0, utilities_1.xmlArray)(raw, "qf:proposalResult", "deltas", "unit").map(parseDelta);
+    return deltas;
+}
+exports.fixEdits = fixEdits;
+const parsePackageGeneric = (generic) => {
+    // Read the single affectedObject node directly (not as an array)
+    const o = (0, utilities_1.xmlNode)(generic, "affectedObjects", "affectedObject");
+    if (!o)
+        throw new Error("No affectedObject found in generic.affectedObjects");
+    const { uri, type, name, parentUri, packageName } = (0, utilities_1.xmlNodeAttr)(o);
+    const newPackage = (0, utilities_1.xmlNode)((0, utilities_1.xmlNode)(o, "changePackageDelta"), "newPackage");
+    const affectedObjects = {
+        uri,
+        type,
+        name,
+        oldPackage: packageName,
+        newPackage,
+        parentUri,
+        userContent: o.userContent
+    };
+    const { ignoreSyntaxErrorsAllowed, ignoreSyntaxErrors, transport, userContent = "", adtObjectUri = "", title } = generic;
+    return {
+        title,
+        oldPackage: packageName,
+        newPackage,
+        ignoreSyntaxErrorsAllowed,
+        ignoreSyntaxErrors,
+        transport,
+        adtObjectUri: adtObjectUri,
+        userContent: (0, html_entities_1.decode)(userContent),
+        affectedObjects: affectedObjects // only one affected object for change package
+    };
+};
+const parseGeneric = (generic) => {
+    const affectedObjects = (0, utilities_1.xmlArray)(generic, "affectedObjects", "affectedObject").map(o => {
+        const { uri, type, name, parentUri } = (0, utilities_1.xmlNodeAttr)(o);
+        const textReplaceDeltas = (0, utilities_1.xmlArray)(o, "textReplaceDeltas", "textReplaceDelta").map(z => {
+            return {
+                rangeFragment: (0, urlparser_1.parseUri)((0, utilities_1.xmlNode)(z, "rangeFragment")).range,
+                contentOld: (0, utilities_1.xmlNode)(z, "contentOld"),
+                contentNew: (0, utilities_1.xmlNode)(z, "contentNew")
+            };
+        });
+        return {
+            uri,
+            type,
+            name,
+            parentUri,
+            userContent: o.userContent,
+            textReplaceDeltas
+        };
+    });
+    const { ignoreSyntaxErrorsAllowed, ignoreSyntaxErrors, transport, userContent = "", adtObjectUri = "", title } = generic;
+    return {
+        title,
+        ignoreSyntaxErrorsAllowed,
+        ignoreSyntaxErrors,
+        transport,
+        adtObjectUri: (0, urlparser_1.parseUri)(adtObjectUri),
+        userContent: (0, html_entities_1.decode)(userContent),
+        affectedObjects
+    };
+};
+function parseChangePackageRefactoring(body) {
+    const raw = (0, utilities_1.fullParse)(body, { removeNSPrefix: true });
+    const root = (0, utilities_1.xmlNode)(raw, "changePackageRefactoring");
+    const { ignoreSyntaxErrorsAllowed, ignoreSyntaxErrors, transport, adtObjectUri, affectedObjects, userContent } = parsePackageGeneric((0, utilities_1.xmlNode)(root || raw, "genericRefactoring")); // depending on the caller the generic refactoring might be wrapped or not
+    return {
+        oldPackage: (0, utilities_1.xmlNode)(root, "oldPackage") || "",
+        newPackage: (0, utilities_1.xmlNode)(root, "newPackage") || "",
+        adtObjectUri: adtObjectUri,
+        ignoreSyntaxErrorsAllowed: !!ignoreSyntaxErrorsAllowed,
+        ignoreSyntaxErrors: !!ignoreSyntaxErrors,
+        transport: transport || "",
+        affectedObjects,
+        userContent: userContent
+    };
+}
+function parseRenameRefactoring(body) {
+    const raw = (0, utilities_1.fullParse)(body, { removeNSPrefix: true });
+    const root = (0, utilities_1.xmlNode)(raw, "renameRefactoring");
+    const { ignoreSyntaxErrorsAllowed, ignoreSyntaxErrors, transport, adtObjectUri, affectedObjects, userContent } = parseGeneric((0, utilities_1.xmlNode)(root || raw, "genericRefactoring")); // depending on the caller the generic refactoring might be wrapped or not
+    return {
+        oldName: (0, utilities_1.xmlNode)(root, "oldName") || "",
+        newName: (0, utilities_1.xmlNode)(root, "newName") || "",
+        adtObjectUri,
+        ignoreSyntaxErrorsAllowed: !!ignoreSyntaxErrorsAllowed,
+        ignoreSyntaxErrors: !!ignoreSyntaxErrors,
+        transport,
+        affectedObjects,
+        userContent: userContent
+    };
+}
+async function renameEvaluate(h, uri, line, startColumn, endColumn) {
+    const qs = {
+        step: `evaluate`,
+        rel: `http://www.sap.com/adt/relations/refactoring/rename`,
+        uri: `${uri}#start=${line},${startColumn};end=${line},${endColumn}`
+    };
+    const headers = { "Content-Type": "application/*", Accept: "application/*" };
+    const response = await h.request("/sap/bc/adt/refactorings", {
+        method: "POST",
+        qs: qs,
+        headers: headers
+    });
+    return parseRenameRefactoring(response.body);
+}
+exports.renameEvaluate = renameEvaluate;
+const serializeAffectedObject = (o) => {
+    const pu = o.parentUri ? `adtcore:parentUri="${o.parentUri}"` : "";
+    return `<generic:affectedObject adtcore:name="${o.name}" ${pu} adtcore:type="${o.type}" adtcore:uri="${o.uri}">
+        <generic:textReplaceDeltas>
+          ${o.textReplaceDeltas
+        .map(y => {
+        return `<generic:textReplaceDelta>
+            <generic:rangeFragment>${(0, _1.rangeToString)(y.rangeFragment)}</generic:rangeFragment>
+            <generic:contentOld>${(0, utilities_1.encodeEntity)(y.contentOld)}</generic:contentOld>
+            <generic:contentNew>${(0, utilities_1.encodeEntity)(y.contentNew)}</generic:contentNew>
+          </generic:textReplaceDelta>`;
+    })
+        .join("")}
+          </generic:textReplaceDeltas>
+        <generic:userContent>${o.userContent}</generic:userContent>
+      </generic:affectedObject>`;
+};
+const serializeGenericRefactoring = (g) => {
+    return `<?xml version="1.0" encoding="utf-8"?>
+<generic:genericRefactoring xmlns:adtcore="http://www.sap.com/adt/core" xmlns:generic="http://www.sap.com/adt/refactoring/genericrefactoring">
+  <generic:title>${g.title}</generic:title>
+  <generic:adtObjectUri>${(0, urlparser_1.uriPartsToString)(g.adtObjectUri)}</generic:adtObjectUri>
+  <generic:affectedObjects>
+  ${g.affectedObjects.map(serializeAffectedObject).join("\n")}
+  </generic:affectedObjects>
+  <generic:transport>${g.transport}</generic:transport>
+  <generic:ignoreSyntaxErrorsAllowed>${g.ignoreSyntaxErrorsAllowed}</generic:ignoreSyntaxErrorsAllowed>
+  <generic:ignoreSyntaxErrors>${g.ignoreSyntaxErrors}</generic:ignoreSyntaxErrors>
+  <generic:userContent/>
+</generic:genericRefactoring>`;
+};
+const addPackageAffectedObject = (o) => {
+    return `<generic:affectedObject adtcore:description="Program" adtcore:name="${o.name}" adtcore:packageName="${o.oldPackage}" adtcore:type="${o.type}" adtcore:uri="${o.uri}">
+        <generic:userContent></generic:userContent>
+        <generic:changePackageDelta>
+          <generic:newPackage>${o.newPackage}</generic:newPackage>
+        </generic:changePackageDelta>
+      </generic:affectedObject>`;
+};
+const serializeChangePackageRefactoring = (changePackageRefactoring, wrapped, transport = "") => {
+    const start = wrapped
+        ? `<changepackage:changePackageRefactoring xmlns:adtcore="http://www.sap.com/adt/core" xmlns:generic="http://www.sap.com/adt/refactoring/genericrefactoring" 
+  xmlns:changepackage="http://www.sap.com/adt/refactoring/changepackagerefactoring">
+  <changepackage:oldPackage>${changePackageRefactoring.oldPackage}</changepackage:oldPackage>
+  <changepackage:newPackage>${changePackageRefactoring.newPackage}</changepackage:newPackage>`
+        : "";
+    const end = wrapped ? `<changepackage:userContent></changepackage:userContent> </changepackage:changePackageRefactoring>` : "";
+    const genns = wrapped
+        ? ""
+        : ` xmlns:generic="http://www.sap.com/adt/refactoring/genericrefactoring" xmlns:adtcore="http://www.sap.com/adt/core"`;
+    const bodyXml = `<?xml version="1.0" encoding="ASCII"?>
+  ${start}
+    <generic:genericRefactoring ${genns}>
+      <generic:title>Change Package</generic:title>
+      <generic:adtObjectUri>${changePackageRefactoring.adtObjectUri}</generic:adtObjectUri>
+      <generic:affectedObjects>
+        ${addPackageAffectedObject(changePackageRefactoring.affectedObjects)}
+      </generic:affectedObjects>
+      <generic:transport>${changePackageRefactoring.transport || transport}</generic:transport>
+      <generic:ignoreSyntaxErrorsAllowed>${changePackageRefactoring.ignoreSyntaxErrorsAllowed}</generic:ignoreSyntaxErrorsAllowed>
+      <generic:ignoreSyntaxErrors>${changePackageRefactoring.ignoreSyntaxErrors}</generic:ignoreSyntaxErrors>
+      <generic:userContent/>
+    </generic:genericRefactoring>
+    ${end}`;
+    return bodyXml;
+};
+const srializeRefactoring = (renameRefactoring, wrapped, transport = "") => {
+    const start = wrapped
+        ? `<rename:renameRefactoring xmlns:adtcore="http://www.sap.com/adt/core" xmlns:generic="http://www.sap.com/adt/refactoring/genericrefactoring" 
+  xmlns:rename="http://www.sap.com/adt/refactoring/renamerefactoring">
+  <rename:oldName>${renameRefactoring.oldName}</rename:oldName>
+  <rename:newName>${renameRefactoring.newName}</rename:newName>`
+        : "";
+    const end = wrapped ? `<rename:userContent/></rename:renameRefactoring>` : "";
+    const genns = wrapped
+        ? ""
+        : ` xmlns:generic="http://www.sap.com/adt/refactoring/genericrefactoring" xmlns:adtcore="http://www.sap.com/adt/core"`;
+    const addAffectedObjects = (affectedObject) => affectedObject.map(serializeAffectedObject);
+    const bodyXml = `<?xml version="1.0" encoding="ASCII"?>
+  ${start}
+    <generic:genericRefactoring ${genns}>
+      <generic:title>Rename Field</generic:title>
+      <generic:adtObjectUri>${renameRefactoring.adtObjectUri.uri}${(0, _1.rangeToString)(renameRefactoring.adtObjectUri.range)}</generic:adtObjectUri>
+      <generic:affectedObjects>
+        ${addAffectedObjects(renameRefactoring.affectedObjects).join("")}
+      </generic:affectedObjects>
+      <generic:transport>${renameRefactoring.transport || transport}</generic:transport>
+      <generic:ignoreSyntaxErrorsAllowed>${renameRefactoring.ignoreSyntaxErrorsAllowed}</generic:ignoreSyntaxErrorsAllowed>
+      <generic:ignoreSyntaxErrors>${renameRefactoring.ignoreSyntaxErrors}</generic:ignoreSyntaxErrors>
+      <generic:userContent/>
+    </generic:genericRefactoring>
+    ${end}`;
+    return bodyXml;
+};
+const extractMethodBody = (proposal) => {
+    const parameters = proposal.parameters
+        .map(p => `<extractmethod:parameter>
+      <extractmethod:id>${(0, utilities_1.encodeEntity)(p.id)}</extractmethod:id>
+      <extractmethod:name>${p.name}</extractmethod:name>
+      <extractmethod:direction>${p.direction}</extractmethod:direction>
+      <extractmethod:byValue>${p.byValue}</extractmethod:byValue>
+      <extractmethod:typeType>${p.typeType}</extractmethod:typeType>
+      <extractmethod:type>${p.type}</extractmethod:type>
+      <extractmethod:userContent>${(0, utilities_1.encodeEntity)(p.userContent)}</extractmethod:userContent>
+    </extractmethod:parameter>`)
+        .join("\n");
+    const exceptions = proposal.exceptions
+        .map(e => `<extractmethod:exception>
+      <extractmethod:name>${e.name}</extractmethod:name>
+      <extractmethod:resumable>${e.resumable}</extractmethod:resumable>
+      <extractmethod:userContent>${e.userContent}</extractmethod:userContent>
+    </extractmethod:exception>`)
+        .join("\n");
+    const exc = exceptions.length
+        ? `<extractmethod:exceptions>${exceptions}</extractmethod:exceptions>  `
+        : `<extractmethod:exceptions/>`;
+    const gr = proposal.genericRefactoring;
+    const affected = gr.affectedObjects
+        .map(o => {
+        const deltas = o.textReplaceDeltas.length === 0
+            ? undefined
+            : o.textReplaceDeltas
+                .map(d => `<generic:textReplaceDelta> <generic:rangeFragment>${d.rangeFragment}</generic:rangeFragment> <generic:contentOld>${(0, utilities_1.encodeEntity)(d.contentOld)}</generic:contentOld> <generic:contentNew>${(0, utilities_1.encodeEntity)(d.contentNew)}</generic:contentNew> </generic:textReplaceDelta>`)
+                .join("\n");
+        const delta = deltas
+            ? `<generic:textReplaceDeltas>${deltas}</generic:textReplaceDeltas>`
+            : ``;
+        return `<generic:affectedObject adtcore:name="${o.name}" adtcore:parentUri="${o.parentUri}" adtcore:type="${o.type}" adtcore:uri="${o.uri}">
+        <generic:userContent>${o.userContent}</generic:userContent>
+        ${delta}
+      </generic:affectedObject>`;
+    })
+        .join("\n");
+    return `<?xml version="1.0" encoding="ASCII"?>
+<extractmethod:extractMethodRefactoring xmlns:adtcore="http://www.sap.com/adt/core" xmlns:extractmethod="http://www.sap.com/adt/refactoring/extractmethodrefactoring" xmlns:generic="http://www.sap.com/adt/refactoring/genericrefactoring">
+  <extractmethod:name>${proposal.name}</extractmethod:name>
+  <extractmethod:isStatic>${proposal.isStatic}</extractmethod:isStatic>
+  <extractmethod:visibility>${proposal.visibility}</extractmethod:visibility>
+  <extractmethod:classBasedExceptions>${proposal.classBasedExceptions}</extractmethod:classBasedExceptions>
+  <extractmethod:parameters>
+  ${parameters}
+  </extractmethod:parameters>
+  ${exc}
+  <extractmethod:content>${(0, utilities_1.encodeEntity)(proposal.content)}</extractmethod:content>
+  <generic:genericRefactoring>
+    <generic:title>${gr.title}</generic:title>
+    <generic:adtObjectUri>${(0, urlparser_1.uriPartsToString)(gr.adtObjectUri)}</generic:adtObjectUri>
+    <generic:affectedObjects>
+    ${affected}
+    </generic:affectedObjects>
+    <generic:transport>${gr.transport}</generic:transport>
+    <generic:ignoreSyntaxErrorsAllowed>${gr.ignoreSyntaxErrorsAllowed}</generic:ignoreSyntaxErrorsAllowed>
+    <generic:ignoreSyntaxErrors>${gr.ignoreSyntaxErrors}</generic:ignoreSyntaxErrors>
+    <generic:userContent>${gr.userContent}</generic:userContent>
+  </generic:genericRefactoring>
+  <extractmethod:className>ZAPIADT_TESTCASE_CLASS1${proposal}</extractmethod:className>
+  <extractmethod:isEventAllowed>${proposal.isEventAllowed}</extractmethod:isEventAllowed>
+  <extractmethod:isEvent>${proposal.isEvent}</extractmethod:isEvent>
+  <extractmethod:userContent>${(0, utilities_1.encodeEntity)(proposal.userContent)}</extractmethod:userContent>
+  <extractmethod:isForTesting>${proposal.isForTesting}</extractmethod:isForTesting>
+</extractmethod:extractMethodRefactoring>`;
+};
+const parseExtractMethodEval = (body) => {
+    const root = (0, utilities_1.fullParse)(body, {
+        removeNSPrefix: true
+    }).extractMethodRefactoring;
+    const parameters = (0, utilities_1.xmlArray)(root, "parameters", "parameter");
+    const exceptions = (0, utilities_1.xmlArray)(root, "exceptions", "exception");
+    const { name, isStatic, visibility, classBasedExceptions, content, className, isEventAllowed, isEvent, userContent } = root;
+    const genericRefactoring = parseGeneric(root.genericRefactoring);
+    const resp = {
+        name,
+        isStatic,
+        visibility,
+        classBasedExceptions,
+        genericRefactoring,
+        content,
+        className,
+        isForTesting: false,
+        isEventAllowed,
+        isEvent,
+        userContent: (0, html_entities_1.decode)(userContent),
+        parameters,
+        exceptions
+    };
+    return resp;
+};
+async function changePackagePreview(h, changePackageRefactoring, transport) {
+    console.log("changePackageRefactoring here", changePackageRefactoring);
+    const qs = {
+        step: `preview`,
+        rel: `http://www.sap.com/adt/relations/refactoring/changepackage`
+    };
+    const bodyXml = serializeChangePackageRefactoring(changePackageRefactoring, true, transport);
+    const headers = { "Content-Type": "application/*", Accept: "application/*" };
+    console.log(" changePackagePreview bodyXml", bodyXml);
+    const response = await h.request("/sap/bc/adt/refactorings", {
+        method: "POST",
+        qs: qs,
+        body: bodyXml,
+        headers: headers
+    });
+    console.log(" changePackagePreview response.body", response.body);
+    const parsed = parseChangePackageRefactoring(response.body);
+    return { ...parsed, transport: parsed.transport || transport };
+}
+exports.changePackagePreview = changePackagePreview;
+async function changePackageExecute(h, packagename) {
+    const qs = {
+        step: `execute`
+    };
+    const headers = { "Content-Type": "application/*", Accept: "application/*" };
+    const body = serializeChangePackageRefactoring(packagename, false);
+    console.log(" changePackageExecute body", body);
+    const response = await h.request("/sap/bc/adt/refactorings", {
+        method: "POST",
+        qs: qs,
+        body,
+        headers: headers
+    });
+    console.log(" changePackageExecute response.body", response.body);
+    const result = parseChangePackageRefactoring(response.body);
+    return { ...result, transport: result.transport || packagename.transport };
+}
+exports.changePackageExecute = changePackageExecute;
+async function renamePreview(h, renameRefactoring, transport) {
+    const qs = {
+        step: `preview`,
+        rel: `http://www.sap.com/adt/relations/refactoring/rename`
+    };
+    const bodyXml = srializeRefactoring(renameRefactoring, true, transport);
+    const headers = { "Content-Type": "application/*", Accept: "application/*" };
+    const response = await h.request("/sap/bc/adt/refactorings", {
+        method: "POST",
+        qs: qs,
+        body: bodyXml,
+        headers: headers
+    });
+    const parsed = parseRenameRefactoring(response.body);
+    return { ...parsed, transport: parsed.transport || transport };
+}
+exports.renamePreview = renamePreview;
+async function renameExecute(h, rename) {
+    const qs = {
+        step: `execute`
+    };
+    const headers = { "Content-Type": "application/*", Accept: "application/*" };
+    const body = srializeRefactoring(rename, false);
+    const response = await h.request("/sap/bc/adt/refactorings", {
+        method: "POST",
+        qs: qs,
+        body,
+        headers: headers
+    });
+    const result = parseRenameRefactoring(response.body);
+    return { ...result, transport: result.transport || rename.transport };
+}
+exports.renameExecute = renameExecute;
+async function extractMethodEvaluate(h, uri, range) {
+    const qs = {
+        step: `evaluate`,
+        rel: `http://www.sap.com/adt/relations/refactoring/extractmethod`,
+        uri: `${uri}#start=${range.start.line},${range.start.column};end=${range.end.line},${range.end.column}`
+    };
+    const headers = { "Content-Type": "application/*", Accept: "application/*" };
+    const opts = { method: "POST", qs, headers };
+    const response = await h.request("/sap/bc/adt/refactorings", opts);
+    return parseExtractMethodEval(response.body);
+}
+exports.extractMethodEvaluate = extractMethodEvaluate;
+async function extractMethodPreview(h, proposal) {
+    const body = extractMethodBody(proposal);
+    const qs = {
+        step: `preview`,
+        rel: `http://www.sap.com/adt/relations/refactoring/extractmethod`
+    };
+    const headers = { "Content-Type": "application/*", Accept: "application/*" };
+    const opts = { method: "POST", qs, headers, body };
+    const response = await h.request("/sap/bc/adt/refactorings", opts);
+    const raw = (0, utilities_1.fullParse)(response.body, {
+        removeNSPrefix: true
+    }).genericRefactoring;
+    return parseGeneric(raw);
+}
+exports.extractMethodPreview = extractMethodPreview;
+async function extractMethodExecute(h, refactoring) {
+    const body = serializeGenericRefactoring(refactoring);
+    const qs = { step: `execute` };
+    const headers = { "Content-Type": "application/*", Accept: "application/*" };
+    const opts = { method: "POST", qs, headers, body };
+    const response = await h.request("/sap/bc/adt/refactorings", opts);
+    const raw = (0, utilities_1.fullParse)(response.body, {
+        removeNSPrefix: true
+    }).genericRefactoring;
+    return parseGeneric(raw);
+}
+exports.extractMethodExecute = extractMethodExecute;

package/build/api/revisions.d.ts

@@ -0,0 +1,12 @@
+import { AdtHTTP } from "../AdtHTTP";
+import { AbapObjectStructure, classIncludes } from "./objectstructure";
+export interface Revision {
+    uri: string;
+    date: string;
+    author: string;
+    version: string;
+    versionTitle: string;
+}
+export declare function getRevisionLink(struct: AbapObjectStructure, includeName?: classIncludes): string;
+export declare function revisions(h: AdtHTTP, objectUrl: string | AbapObjectStructure, includeName?: classIncludes): Promise<Revision[]>;
+//# sourceMappingURL=revisions.d.ts.map

package/build/api/revisions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revisions.d.ts","sourceRoot":"","sources":["../../src/api/revisions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AASpC,OAAO,EACL,mBAAmB,EACnB,aAAa,EAId,MAAM,mBAAmB,CAAA;AAE1B,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,CAAA;CACrB;AAMD,wBAAgB,eAAe,CAC7B,MAAM,EAAE,mBAAmB,EAC3B,WAAW,CAAC,EAAE,aAAa,UAY5B;AAUD,wBAAsB,SAAS,CAC7B,CAAC,EAAE,OAAO,EACV,SAAS,EAAE,MAAM,GAAG,mBAAmB,EACvC,WAAW,CAAC,EAAE,aAAa,uBAgC5B"}

package/build/api/revisions.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revisions = exports.getRevisionLink = void 0;
+const AdtException_1 = require("../AdtException");
+const utilities_1 = require("../utilities");
+const objectstructure_1 = require("./objectstructure");
+function extractRevisionLink(links) {
+    return links.find(l => l.rel === "http://www.sap.com/adt/relations/versions");
+}
+function getRevisionLink(struct, includeName) {
+    let link;
+    if ((0, objectstructure_1.isClassStructure)(struct)) {
+        const iname = includeName || "main";
+        const include = struct.includes.find(i => i["class:includeType"] === iname);
+        if (include)
+            link = extractRevisionLink(include.links);
+    }
+    else {
+        link = extractRevisionLink(struct.links);
+    }
+    if (link)
+        return (0, utilities_1.followUrl)(struct.objectUrl, link.href);
+    return "";
+}
+exports.getRevisionLink = getRevisionLink;
+const extractVersion = (entry) => {
+    const ADTTYPE = "application/vnd.sap.adt.transportrequests.v1+xml";
+    const base = (0, utilities_1.xmlNode)(entry, "atom:link");
+    if (Array.isArray(base)) {
+        const vlink = base.find(l => l["@_type"] === ADTTYPE) || base[0];
+        return (0, utilities_1.xmlNode)(vlink, "@_adtcore:name") || "";
+    }
+    else
+        return (0, utilities_1.xmlNode)(base, "@_adtcore:name") || "";
+};
+async function revisions(h, objectUrl, includeName) {
+    const str = (0, utilities_1.isString)(objectUrl)
+        ? await (0, objectstructure_1.objectStructure)(h, objectUrl)
+        : objectUrl;
+    const name = str.metaData["adtcore:name"];
+    const revisionUrl = getRevisionLink(str, includeName);
+    if (!revisionUrl)
+        throw (0, AdtException_1.adtException)(`Revision URL not found for object ${name}`);
+    const headers = { Accept: "application/atom+xml;type=feed" };
+    const response = await h.request(revisionUrl, {
+        method: "GET",
+        headers
+    });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    const versions = (0, utilities_1.xmlArray)(raw, "atom:feed", "atom:entry").map((entry) => {
+        const uri = (0, utilities_1.xmlNode)(entry, "atom:content", "@_src") || "";
+        const version = extractVersion(entry);
+        const versionTitle = (0, utilities_1.xmlNode)(entry, "atom:title") || "";
+        const date = (0, utilities_1.xmlNode)(entry, "atom:updated") || "";
+        const author = (0, utilities_1.xmlNode)(entry, "atom:author", "atom:name");
+        const r = { uri, version, versionTitle, date, author };
+        return r;
+    });
+    return versions;
+}
+exports.revisions = revisions;

package/build/api/search.d.ts

@@ -0,0 +1,25 @@
+import { AdtHTTP } from "../AdtHTTP";
+export interface SearchResult {
+    "adtcore:description"?: string;
+    "adtcore:name": string;
+    "adtcore:packageName"?: string;
+    "adtcore:type": string;
+    "adtcore:uri": string;
+}
+export interface PathStep {
+    "adtcore:name": string;
+    "adtcore:type": string;
+    "adtcore:uri": string;
+    "projectexplorer:category": string;
+}
+export type PackageValueHelpType = "applicationcomponents" | "softwarecomponents" | "transportlayers" | "translationrelevances";
+export interface PackageValueHelpResult {
+    name: string;
+    description: string;
+    data: string;
+}
+export declare function searchObject(h: AdtHTTP, query: string, objType?: string, maxResults?: number): Promise<SearchResult[]>;
+export declare function findObjectPath(h: AdtHTTP, objectUrl: string): Promise<PathStep[]>;
+export declare function abapDocumentation(h: AdtHTTP, objectUri: string, body: string, line: number, column: number, language?: string): Promise<string>;
+export declare function packageSearchHelp(h: AdtHTTP, type: PackageValueHelpType, name?: string): Promise<PackageValueHelpResult[]>;
+//# sourceMappingURL=search.d.ts.map

package/build/api/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/api/search.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAGpC,MAAM,WAAW,YAAY;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,cAAc,EAAE,MAAM,CAAA;IACtB,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,cAAc,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,QAAQ;IACvB,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;IACrB,0BAA0B,EAAE,MAAM,CAAA;CACnC;AAED,MAAM,MAAM,oBAAoB,GAC5B,uBAAuB,GACvB,oBAAoB,GACpB,iBAAiB,GACjB,uBAAuB,CAAA;AAE3B,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;CACb;AACD,wBAAsB,YAAY,CAChC,CAAC,EAAE,OAAO,EACV,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,GAAE,MAAY,2BAuBzB;AAED,wBAAsB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,uBAcjE;AAED,wBAAsB,iBAAiB,CACrC,CAAC,EAAE,OAAO,EACV,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,QAAQ,SAAO,mBAgBhB;AAED,wBAAsB,iBAAiB,CACrC,CAAC,EAAE,OAAO,EACV,IAAI,EAAE,oBAAoB,EAC1B,IAAI,SAAM,qCAgBX"}

package/build/api/search.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageSearchHelp = exports.abapDocumentation = exports.findObjectPath = exports.searchObject = void 0;
+const AdtException_1 = require("../AdtException");
+const utilities_1 = require("../utilities");
+async function searchObject(h, query, objType, maxResults = 100) {
+    const qs = { operation: "quickSearch", query, maxResults };
+    if (objType)
+        qs.objectType = objType.replace(/\/.*$/, "");
+    const response = await h.request(`/sap/bc/adt/repository/informationsystem/search`, { qs, headers: { Accept: "application/*" } });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    return (0, utilities_1.xmlArray)(raw, "adtcore:objectReferences", "adtcore:objectReference").map((sr) => {
+        const result = (0, utilities_1.xmlNodeAttr)(sr);
+        // older systems return things like "ZREPORT (PROGRAM)"...
+        const r = result["adtcore:name"].match(/([^\s]*)\s*\((.*)\)/);
+        if (r) {
+            result["adtcore:name"] = r[1];
+            if (!result["adtcore:description"])
+                result["adtcore:description"] = r[2];
+        }
+        return result;
+    });
+}
+exports.searchObject = searchObject;
+async function findObjectPath(h, objectUrl) {
+    (0, AdtException_1.ValidateObjectUrl)(objectUrl);
+    const qs = { uri: objectUrl };
+    const response = await h.request(`/sap/bc/adt/repository/nodepath`, {
+        method: "POST",
+        qs
+    });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    return (0, utilities_1.xmlArray)(raw, "projectexplorer:nodepath", "projectexplorer:objectLinkReferences", "objectLinkReference").map(utilities_1.xmlNodeAttr);
+}
+exports.findObjectPath = findObjectPath;
+async function abapDocumentation(h, objectUri, body, line, column, language = "EN") {
+    (0, AdtException_1.ValidateObjectUrl)(objectUri);
+    const headers = {
+        "Content-Type": "text/plain",
+        Accept: "application/vnd.sap.adt.docu.v1+html,text/html"
+    };
+    const uri = `${objectUri}#start=${line},${column}`;
+    const qs = { uri, language, format: "eclipse" };
+    const response = await h.request(`/sap/bc/adt/docu/abap/langu`, {
+        method: "POST",
+        qs,
+        headers,
+        body
+    });
+    return response.body;
+}
+exports.abapDocumentation = abapDocumentation;
+async function packageSearchHelp(h, type, name = "*") {
+    const headers = { Accept: "application/*" };
+    const qs = { name };
+    const uri = `/sap/bc/adt/packages/valuehelps/${type}`;
+    const response = await h.request(uri, { qs, headers });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    return (0, utilities_1.xmlArray)(raw, "nameditem:namedItemList", "nameditem:namedItem").map((item) => {
+        return {
+            name: item["nameditem:name"],
+            description: item["nameditem:description"],
+            data: item["nameditem:data"]
+        };
+    });
+}
+exports.packageSearchHelp = packageSearchHelp;