catalyst-relay 0.6.1 → 0.6.3

package/dist/index.mjs

@@ -1025,22 +1025,6 @@ function escapeXml(str) {
   }
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
-function dictToAbapXml(data, root = "DATA") {
-  const innerElements = Object.entries(data).map(([key, value]) => {
-    if (value) {
-      return `<${key}>${escapeXml(value)}</${key}>`;
-    }
-    return `<${key}/>`;
-  }).join("\n            ");
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
-    <asx:values>
-        <${root}>
-            ${innerElements}
-        </${root}>
-    </asx:values>
-</asx:abap>`;
-}
 
 // src/core/utils/csrf.ts
 var FETCH_CSRF_TOKEN = "fetch";
@@ -1868,6 +1852,23 @@ async function updateObject(client, object, lockHandle, transport) {
 }
 
 // src/core/adt/craud/classInclude.ts
+async function readClassInclude(client, className, includeType) {
+  const [config, configErr] = requireConfig("aclass");
+  if (configErr) return err(configErr);
+  debug(`Read class include ${className}/${includeType}`);
+  const [response, requestErr] = await client.request({
+    method: "GET",
+    path: `/sap/bc/adt/${config.endpoint}/${className.toLowerCase()}/includes/${includeType}`,
+    headers: { "Accept": "text/plain" }
+  });
+  const [content, checkErr] = await checkResponse(
+    response,
+    requestErr,
+    `Failed to read ${includeType} include of class ${className}`
+  );
+  if (checkErr) return err(checkErr);
+  return ok(content);
+}
 async function updateClassInclude(client, className, includeType, source, lockHandle, transport) {
   const [config, configErr] = requireConfig("aclass");
   if (configErr) return err(configErr);
@@ -3045,35 +3046,102 @@ function parseSearchResults(xml) {
   return ok(results);
 }
 
-// src/core/adt/transports/createTransport.ts
-async function createTransport(client, config) {
-  const body = dictToAbapXml({
-    DEVCLASS: config.package,
-    REQUEST_TEXT: config.description,
-    REF: "",
-    OPERATION: "I"
+// src/core/adt/transports/getTransportTargets.ts
+var TARGET_VALUEHELP_PATH = "/sap/bc/adt/cts/transportrequests/valuehelp/target?name=*";
+var NAMEDITEM_CONTENT_TYPE = "application/vnd.sap.adt.nameditems.v1+xml";
+var NAMEDITEM_NS = "http://www.sap.com/adt/nameditem";
+async function getTransportTargets(client) {
+  const [response, requestErr] = await client.request({
+    method: "GET",
+    path: TARGET_VALUEHELP_PATH,
+    headers: { Accept: NAMEDITEM_CONTENT_TYPE }
   });
+  if (requestErr) return err(requestErr);
+  if (!response.ok) {
+    const text2 = await response.text();
+    return err(new Error(`Failed to fetch transport targets: ${extractError(text2)}`));
+  }
+  const text = await response.text();
+  const [targets, parseErr] = extractTargets(text);
+  if (parseErr) return err(parseErr);
+  return ok(targets);
+}
+function extractTargets(xml) {
+  const [doc, parseErr] = safeParseXml(xml);
+  if (parseErr) return err(parseErr);
+  const targets = [];
+  const items = doc.getElementsByTagNameNS(NAMEDITEM_NS, "namedItem");
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (!item) continue;
+    const name = item.getElementsByTagNameNS(NAMEDITEM_NS, "name")[0]?.textContent;
+    if (!name || !name.trim()) continue;
+    const description = item.getElementsByTagNameNS(NAMEDITEM_NS, "description")[0]?.textContent;
+    targets.push({ name: name.trim(), description: (description ?? "").trim() });
+  }
+  return ok(targets);
+}
+
+// src/core/adt/transports/createTransport.ts
+var TRANSPORTREQUESTS_PATH = "/sap/bc/adt/cts/transportrequests";
+var TM_CONTENT_TYPE = "application/vnd.sap.adt.transportorganizer.v1+xml";
+var TM_NS = "http://www.sap.com/cts/adt/tm";
+var TRANSPORT_TYPE_CODES = {
+  workbench: "K",
+  customizing: "W"
+};
+async function createTransport(client, config, owner) {
+  const [target, targetErr] = await resolveTarget(client, config.target);
+  if (targetErr) return err(targetErr);
+  const typeCode = TRANSPORT_TYPE_CODES[config.type ?? "workbench"];
+  const body = `<?xml version="1.0" encoding="UTF-8"?>
+<tm:root xmlns:tm="${TM_NS}" tm:useraction="newrequest">
+  <tm:request tm:desc="${escapeXml(config.description)}" tm:type="${typeCode}" tm:target="${escapeXml(target)}" tm:cts_project="">
+    <tm:task tm:owner="${escapeXml(owner)}"/>
+  </tm:request>
+</tm:root>`;
   const [response, requestErr] = await client.request({
     method: "POST",
-    path: "/sap/bc/adt/cts/transports",
+    path: TRANSPORTREQUESTS_PATH,
     headers: {
-      "Content-Type": "application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.CreateCorrectionRequest",
-      "Accept": "text/plain"
+      "Content-Type": TM_CONTENT_TYPE,
+      "Accept": TM_CONTENT_TYPE
     },
     body
   });
   if (requestErr) return err(requestErr);
   if (!response.ok) {
     const text2 = await response.text();
-    const errorMsg = extractError(text2);
-    return err(new Error(`Failed to create transport for ${config.package}: ${errorMsg}`));
+    return err(new Error(`Failed to create transport: ${extractError(text2)}`));
   }
   const text = await response.text();
-  const transportId = text.trim().split("/").pop();
-  if (!transportId) {
-    return err(new Error("Failed to parse transport ID from response"));
+  return extractTransportNumber(text);
+}
+async function resolveTarget(client, explicit) {
+  if (explicit) return ok(explicit);
+  const [targets, targetsErr] = await getTransportTargets(client);
+  if (targetsErr) return err(targetsErr);
+  if (targets.length === 0) {
+    return err(new Error("No transport targets available; pass an explicit target."));
+  }
+  if (targets.length === 1) {
+    return ok(targets[0].name);
   }
-  return ok(transportId);
+  const options = targets.map((t) => `${t.name} (${t.description})`).join(", ");
+  return err(new Error(
+    `Multiple transport targets available; pass an explicit target. Options: ${options}`
+  ));
+}
+function extractTransportNumber(xml) {
+  const [doc, parseErr] = safeParseXml(xml);
+  if (parseErr) return err(parseErr);
+  const request4 = doc.getElementsByTagNameNS(TM_NS, "request")[0];
+  if (!request4) return err(new Error("Failed to parse transport number from response"));
+  const number = request4.getAttributeNS(TM_NS, "number") || request4.getAttribute("tm:number");
+  if (!number || !number.trim()) {
+    return err(new Error("Failed to parse transport number from response"));
+  }
+  return ok(number.trim());
 }
 
 // src/core/adt/transports/parseTransportTasks.ts
@@ -3584,6 +3652,12 @@ async function update(state, requestor, object, transport) {
   return ok(void 0);
 }
 
+// src/client/methods/craud/specialcases/classes/readClassInclude.ts
+async function readClassInclude2(state, requestor, className, includeType) {
+  if (!state.session) return err(new Error("Not logged in"));
+  return readClassInclude(requestor, className, includeType);
+}
+
 // src/client/methods/craud/specialcases/classes/writeClassInclude.ts
 async function writeClassInclude(state, requestor, className, includeType, source, transport) {
   if (!state.session) return err(new Error("Not logged in"));
@@ -3734,7 +3808,7 @@ async function whereUsed(state, requestor, object) {
 // src/client/methods/transport/createTransport.ts
 async function createTransport2(state, requestor, transportConfig) {
   if (!state.session) return err(new Error("Not logged in"));
-  return createTransport(requestor, transportConfig);
+  return createTransport(requestor, transportConfig, state.session.username);
 }
 
 // src/client/methods/transport/deleteTransport.ts
@@ -4120,6 +4194,9 @@ var ADTClientImpl = class {
   async update(object, transport) {
     return update(this.state, this.requestor, object, transport);
   }
+  async readClassInclude(className, includeType) {
+    return readClassInclude2(this.state, this.requestor, className, includeType);
+  }
   async writeClassInclude(className, includeType, source, transport) {
     return writeClassInclude(this.state, this.requestor, className, includeType, source, transport);
   }