catalyst-relay 0.5.9 → 0.5.11

package/dist/index.js

@@ -1226,6 +1226,14 @@ var OBJECT_CONFIG_MAP = {
     type: "PROG/P",
     label: "ABAP Program" /* PROGRAM */,
     extension: "asprog"
+  },
+  "asinc": {
+    endpoint: "programs/includes",
+    nameSpace: 'xmlns:include="http://www.sap.com/adt/programs/includes"',
+    rootName: "include:abapInclude",
+    type: "PROG/I",
+    label: "ABAP Include" /* INCLUDE */,
+    extension: "asinc"
   }
 };
 function getConfigByExtension(extension) {
@@ -1287,6 +1295,80 @@ async function readObject(client, object) {
   return ok(result);
 }
 
+// src/core/adt/discovery/whereUsed.ts
+async function findWhereUsed(client, object) {
+  const config = getConfigByExtension(object.extension);
+  if (!config) {
+    return err(new Error(`Unsupported extension: ${object.extension}`));
+  }
+  const uri = `/sap/bc/adt/${config.endpoint}/${object.name}`;
+  const body = `<?xml version="1.0" encoding="UTF-8"?>
+    <usagereferences:usageReferenceRequest xmlns:usagereferences="http://www.sap.com/adt/ris/usageReferences">
+      <usagereferences:affectedObjects/>
+    </usagereferences:usageReferenceRequest>`;
+  const [response, requestErr] = await client.request({
+    method: "POST",
+    path: "/sap/bc/adt/repository/informationsystem/usageReferences",
+    params: {
+      "uri": uri,
+      "ris_request_type": "usageReferences"
+    },
+    headers: {
+      "Content-Type": "application/vnd.sap.adt.repository.usagereferences.request.v1+xml",
+      "Accept": "application/vnd.sap.adt.repository.usagereferences.result.v1+xml"
+    },
+    body
+  });
+  if (requestErr) {
+    return err(requestErr);
+  }
+  if (!response.ok) {
+    const text2 = await response.text();
+    const errorMsg = extractError(text2);
+    return err(new Error(`Where-used query failed: ${errorMsg}`));
+  }
+  const text = await response.text();
+  const [dependencies, parseErr] = parseWhereUsed(text);
+  if (parseErr) {
+    return err(parseErr);
+  }
+  return ok(dependencies);
+}
+function parseWhereUsed(xml) {
+  const [doc, parseErr] = safeParseXml(xml);
+  if (parseErr) {
+    return err(parseErr);
+  }
+  const dependencies = [];
+  const referencedObjects = doc.getElementsByTagNameNS(
+    "http://www.sap.com/adt/ris/usageReferences",
+    "referencedObject"
+  );
+  for (let i = 0; i < referencedObjects.length; i++) {
+    const refObj = referencedObjects[i];
+    if (!refObj) continue;
+    const adtObject = refObj.getElementsByTagNameNS(
+      "http://www.sap.com/adt/ris/usageReferences",
+      "adtObject"
+    )[0];
+    if (!adtObject) continue;
+    const name = adtObject.getAttributeNS("http://www.sap.com/adt/core", "name") || adtObject.getAttribute("adtcore:name");
+    const type = adtObject.getAttributeNS("http://www.sap.com/adt/core", "type") || adtObject.getAttribute("adtcore:type");
+    if (!name || !type) continue;
+    const config = getConfigByType(type);
+    if (!config) continue;
+    const packageRef = adtObject.getElementsByTagNameNS("http://www.sap.com/adt/core", "packageRef")[0];
+    const packageName = packageRef ? packageRef.getAttributeNS("http://www.sap.com/adt/core", "name") || packageRef.getAttribute("adtcore:name") : "";
+    dependencies.push({
+      name,
+      extension: config.extension,
+      package: packageName || "",
+      usageType: "reference"
+    });
+  }
+  return ok(dependencies);
+}
+
 // src/core/adt/craud/lock.ts
 async function lockObject(client, object) {
   const [config, configErr] = requireConfig(object.extension);
@@ -1335,6 +1417,135 @@ async function unlockObject(client, object, lockHandle) {
   return ok(void 0);
 }
 
+// src/core/adt/craud/delete.ts
+async function deleteObject(client, object, lockHandle, transport) {
+  const [config, configErr] = requireConfig(object.extension);
+  if (configErr) return err(configErr);
+  const params = {
+    "lockHandle": lockHandle
+  };
+  if (transport) {
+    params["corrNr"] = transport;
+  }
+  const [response, requestErr] = await client.request({
+    method: "DELETE",
+    path: `/sap/bc/adt/${config.endpoint}/${object.name}/source/main`,
+    params,
+    headers: { "Accept": "text/plain" }
+  });
+  const [_, checkErr] = await checkResponse(
+    response,
+    requestErr,
+    `Failed to delete ${config.label} ${object.name}`
+  );
+  if (checkErr) return err(checkErr);
+  return ok(void 0);
+}
+
+// src/core/adt/craud/multiDelete.ts
+var ExternalReferencesError = class extends Error {
+  constructor(references) {
+    super(`Cannot delete: ${references.length} external reference(s) prevent the operation`);
+    this.references = references;
+    this.name = "ExternalReferencesError";
+  }
+};
+function objKey(o) {
+  return `${o.name.toLowerCase()}|${o.extension}`;
+}
+async function multiDeleteObjects(client, objects, transport) {
+  if (objects.length === 0) return ok([]);
+  for (const obj of objects) {
+    if (!getConfigByExtension(obj.extension)) {
+      return err(new Error(`Unsupported extension: ${obj.extension}`));
+    }
+  }
+  const setKeys = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const obj of objects) {
+    const key = objKey(obj);
+    if (setKeys.has(key)) continue;
+    setKeys.add(key);
+    unique.push(obj);
+  }
+  const whereUsedResults = await Promise.all(
+    unique.map((obj) => findWhereUsed(client, obj))
+  );
+  for (let i = 0; i < whereUsedResults.length; i++) {
+    const [, e] = whereUsedResults[i];
+    if (e) return err(new Error(`where-used failed for ${unique[i].name}: ${e.message}`));
+  }
+  const referencers = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  const externalRefs = [];
+  for (const obj of unique) {
+    referencers.set(objKey(obj), []);
+    dependents.set(objKey(obj), []);
+  }
+  for (let i = 0; i < unique.length; i++) {
+    const obj = unique[i];
+    const oKey = objKey(obj);
+    const [deps] = whereUsedResults[i];
+    for (const dep of deps) {
+      const dKey = objKey(dep);
+      if (dKey === oKey) continue;
+      if (!setKeys.has(dKey)) {
+        externalRefs.push({
+          object: { name: obj.name, extension: obj.extension },
+          referencedBy: dep
+        });
+        continue;
+      }
+      referencers.get(oKey).push(dKey);
+      dependents.get(dKey).push(oKey);
+    }
+  }
+  if (externalRefs.length > 0) {
+    return err(new ExternalReferencesError(externalRefs));
+  }
+  const objByKey = /* @__PURE__ */ new Map();
+  for (const obj of unique) objByKey.set(objKey(obj), obj);
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const [k, refs] of referencers.entries()) {
+    inDegree.set(k, refs.length);
+  }
+  const remaining = new Set(setKeys);
+  const results = [];
+  const deleteOne = async (obj) => {
+    const [lockHandle, lockErr] = await lockObject(client, obj);
+    if (lockErr) {
+      return { name: obj.name, extension: obj.extension, status: "error", message: lockErr.message };
+    }
+    const [, deleteErr] = await deleteObject(client, obj, lockHandle, transport);
+    if (deleteErr) {
+      await unlockObject(client, obj, lockHandle);
+      return { name: obj.name, extension: obj.extension, status: "error", message: deleteErr.message };
+    }
+    return { name: obj.name, extension: obj.extension, status: "success" };
+  };
+  while (remaining.size > 0) {
+    const ready = [];
+    for (const key of remaining) {
+      if ((inDegree.get(key) ?? 0) === 0) ready.push(key);
+    }
+    const waveKeys = ready.length > 0 ? ready : [...remaining];
+    const waveObjects = waveKeys.map((k) => objByKey.get(k));
+    const waveResults = await Promise.all(waveObjects.map(deleteOne));
+    for (let i = 0; i < waveResults.length; i++) {
+      const result = waveResults[i];
+      const key = waveKeys[i];
+      results.push(result);
+      remaining.delete(key);
+      if (result.status === "success") {
+        for (const o of dependents.get(key) ?? []) {
+          inDegree.set(o, (inDegree.get(o) ?? 0) - 1);
+        }
+      }
+    }
+  }
+  return ok(results);
+}
+
 // src/core/adt/craud/create.ts
 async function createObject(client, object, packageName, transport, username) {
   const [config, configErr] = requireConfig(object.extension);
@@ -1400,59 +1611,31 @@ async function updateObject(client, object, lockHandle, transport) {
   return ok(void 0);
 }
 
-// src/core/adt/craud/delete.ts
-async function deleteObject(client, object, lockHandle, transport) {
-  const [config, configErr] = requireConfig(object.extension);
-  if (configErr) return err(configErr);
-  const params = {
-    "lockHandle": lockHandle
-  };
-  if (transport) {
-    params["corrNr"] = transport;
-  }
-  const [response, requestErr] = await client.request({
-    method: "DELETE",
-    path: `/sap/bc/adt/${config.endpoint}/${object.name}/source/main`,
-    params,
-    headers: { "Accept": "text/plain" }
-  });
-  const [_, checkErr] = await checkResponse(
-    response,
-    requestErr,
-    `Failed to delete ${config.label} ${object.name}`
-  );
-  if (checkErr) return err(checkErr);
-  return ok(void 0);
-}
-
 // src/core/adt/craud/activation.ts
+var MAX_POLL_ATTEMPTS = 30;
+var RUN_ID_REGEX = /\/activation\/runs\/([^?/]+)/;
 async function activateObjects(client, objects) {
   if (objects.length === 0) {
     return ok([]);
   }
-  const extension = objects[0].extension;
-  const config = getConfigByExtension(extension);
-  if (!config) return err(new Error(`Unsupported extension: ${extension}`));
   for (const obj of objects) {
-    if (obj.extension !== extension) {
-      return err(new Error("All objects must have the same extension for batch activation"));
-    }
+    const config = getConfigByExtension(obj.extension);
+    if (!config) return err(new Error(`Unsupported extension: ${obj.extension}`));
   }
-  const objectRefs = objects.map((obj) => `<adtcore:objectReference
-                adtcore:uri="/sap/bc/adt/${config.endpoint}/${obj.name.toLowerCase()}"
-                adtcore:type="${config.type}"
-                adtcore:name="${obj.name}"
-                adtcore:description="*"/>`).join("\n            ");
+  const objectRefs = objects.map((obj) => {
+    const config = getConfigByExtension(obj.extension);
+    return `<adtcore:objectReference adtcore:uri="/sap/bc/adt/${config.endpoint}/${obj.name.toLowerCase()}" adtcore:type="${config.type}" adtcore:name="${obj.name}"/>`;
+  }).join("\n    ");
   const body = `<?xml version="1.0" encoding="UTF-8"?>
-            <adtcore:objectReferences xmlns:adtcore="http://www.sap.com/adt/core">
-            ${objectRefs}
-            </adtcore:objectReferences>`;
-  const [response, requestErr] = await client.request({
+<adtcore:objectReferences xmlns:adtcore="http://www.sap.com/adt/core">
+    ${objectRefs}
+</adtcore:objectReferences>`;
+  const [startRes, startErr] = await client.request({
     method: "POST",
-    path: "/sap/bc/adt/activation",
+    path: "/sap/bc/adt/activation/runs",
     params: {
       "method": "activate",
-      "preAuditRequested": "true"
+      "preauditRequested": "false"
     },
     headers: {
       "Content-Type": "application/xml",
@@ -1460,23 +1643,54 @@ async function activateObjects(client, objects) {
     },
     body
   });
-  if (requestErr) {
-    return err(requestErr);
-  }
-  const text = await response.text();
-  debug(`Activation response status: ${response.status}`);
-  debug(`Activation response: ${text.substring(0, 500)}`);
-  if (!response.ok) {
-    const errorMsg = extractError(text);
-    return err(new Error(`Activation failed: ${errorMsg}`));
-  }
-  const [results, parseErr] = extractActivationErrors(objects, text, extension);
-  if (parseErr) {
-    return err(parseErr);
+  if (startErr) return err(startErr);
+  debug(`Activation run start status: ${startRes.status}`);
+  if (!startRes.ok) {
+    const errText = await startRes.text();
+    return err(new Error(`Activation start failed: ${extractError(errText)}`));
+  }
+  const location = startRes.headers.get("location");
+  if (!location) return err(new Error("Activation start response missing Location header"));
+  const runIdMatch = RUN_ID_REGEX.exec(location);
+  if (!runIdMatch || !runIdMatch[1]) {
+    return err(new Error(`Could not extract run ID from Location header: ${location}`));
+  }
+  const runId = runIdMatch[1];
+  debug(`Activation run ID: ${runId}`);
+  let pollAttempt = 0;
+  while (pollAttempt < MAX_POLL_ATTEMPTS) {
+    const [pollRes, pollErr] = await client.request({
+      method: "GET",
+      path: `/sap/bc/adt/activation/runs/${runId}`,
+      params: { "withLongPolling": "true" },
+      headers: { "Accept": "application/xml" }
+    });
+    if (pollErr) return err(pollErr);
+    debug(`Activation poll attempt ${pollAttempt + 1} status: ${pollRes.status}`);
+    if (pollRes.ok) break;
+    pollAttempt++;
+    if (pollAttempt >= MAX_POLL_ATTEMPTS) {
+      const errText = await pollRes.text();
+      return err(new Error(`Activation run ${runId} did not complete: ${extractError(errText)}`));
+    }
   }
+  const [resultsRes, resultsErr] = await client.request({
+    method: "GET",
+    path: `/sap/bc/adt/activation/results/${runId}`,
+    headers: { "Accept": "application/xml" }
+  });
+  if (resultsErr) return err(resultsErr);
+  const resultsText = await resultsRes.text();
+  debug(`Activation results status: ${resultsRes.status}`);
+  debug(`Activation results body: ${resultsText.substring(0, 500)}`);
+  if (!resultsRes.ok) {
+    return err(new Error(`Failed to fetch activation results: ${extractError(resultsText)}`));
+  }
+  const [results, parseErr] = extractActivationErrors(objects, resultsText);
+  if (parseErr) return err(parseErr);
   return ok(results);
 }
-function extractActivationErrors(objects, xml, _extension) {
+function extractActivationErrors(objects, xml) {
   const [doc, parseErr] = safeParseXml(xml);
   if (parseErr) {
     return err(parseErr);
@@ -2075,6 +2289,83 @@ function extractTransports(xml) {
   return ok(transports);
 }
 
+// src/core/adt/discovery/inactiveObjects.ts
+var IOC_NS = "http://www.sap.com/abapxml/inactiveCtsObjects";
+var ADTCORE_NS = "http://www.sap.com/adt/core";
+async function getInactiveObjects(client) {
+  const [response, requestErr] = await client.request({
+    method: "GET",
+    path: "/sap/bc/adt/activation/inactiveobjects",
+    headers: {
+      "Accept": "application/vnd.sap.adt.inactivectsobjects.v1+xml, application/xml;q=0.8"
+    }
+  });
+  if (requestErr) return err(requestErr);
+  if (!response.ok) {
+    const text2 = await response.text();
+    const errorMsg = extractError(text2);
+    return err(new Error(`Failed to fetch inactive objects: ${errorMsg}`));
+  }
+  const text = await response.text();
+  return parseInactiveObjects(text);
+}
+function parseInactiveObjects(xml) {
+  const [doc, parseErr] = safeParseXml(xml);
+  if (parseErr) return err(parseErr);
+  const entries = [];
+  const entryElements = doc.getElementsByTagNameNS(IOC_NS, "entry");
+  for (let i = 0; i < entryElements.length; i++) {
+    const entryEl = entryElements[i];
+    if (!entryEl) continue;
+    const entry = {};
+    const objectEls = entryEl.getElementsByTagNameNS(IOC_NS, "object");
+    if (objectEls.length > 0) {
+      const objectEl = objectEls[0];
+      const objectRef = extractRef(objectEl);
+      if (objectRef) {
+        const user = objectEl.getAttributeNS(IOC_NS, "user") || objectEl.getAttribute("ioc:user") || "";
+        const deletedStr = objectEl.getAttributeNS(IOC_NS, "deleted") || objectEl.getAttribute("ioc:deleted") || "false";
+        entry.object = {
+          user,
+          deleted: deletedStr === "true",
+          ref: objectRef
+        };
+      }
+    }
+    const transportEls = entryEl.getElementsByTagNameNS(IOC_NS, "transport");
+    if (transportEls.length > 0) {
+      const transportEl = transportEls[0];
+      const transportRef = extractRef(transportEl);
+      if (transportRef) {
+        const user = transportEl.getAttributeNS(IOC_NS, "user") || transportEl.getAttribute("ioc:user") || "";
+        const linkedStr = transportEl.getAttributeNS(IOC_NS, "linked") || transportEl.getAttribute("ioc:linked") || "false";
+        entry.transport = {
+          user,
+          linked: linkedStr === "true",
+          ref: transportRef
+        };
+      }
+    }
+    if (entry.object || entry.transport) {
+      entries.push(entry);
+    }
+  }
+  return ok(entries);
+}
+function extractRef(parent) {
+  const refs = parent.getElementsByTagNameNS(IOC_NS, "ref");
+  if (refs.length === 0) return null;
+  const ref = refs[0];
+  const uri = ref.getAttributeNS(ADTCORE_NS, "uri") || ref.getAttribute("adtcore:uri") || "";
+  const type = ref.getAttributeNS(ADTCORE_NS, "type") || ref.getAttribute("adtcore:type") || "";
+  const name = ref.getAttributeNS(ADTCORE_NS, "name") || ref.getAttribute("adtcore:name") || "";
+  const description = ref.getAttributeNS(ADTCORE_NS, "description") || ref.getAttribute("adtcore:description") || void 0;
+  if (!uri && !name) return null;
+  const result = { uri, type, name };
+  if (description) result.description = description;
+  return result;
+}
+
 // src/core/adt/data_extraction/previewParser.ts
 function parseDataPreview(xml, maxRows, isTable) {
   const [doc, parseErr] = safeParseXml(xml);
@@ -2401,80 +2692,6 @@ function parseSearchResults(xml) {
   return ok(results);
 }
 
-// src/core/adt/discovery/whereUsed.ts
-async function findWhereUsed(client, object) {
-  const config = getConfigByExtension(object.extension);
-  if (!config) {
-    return err(new Error(`Unsupported extension: ${object.extension}`));
-  }
-  const uri = `/sap/bc/adt/${config.endpoint}/${object.name}`;
-  const body = `<?xml version="1.0" encoding="UTF-8"?>
-    <usagereferences:usageReferenceRequest xmlns:usagereferences="http://www.sap.com/adt/ris/usageReferences">
-      <usagereferences:affectedObjects/>
-    </usagereferences:usageReferenceRequest>`;
-  const [response, requestErr] = await client.request({
-    method: "POST",
-    path: "/sap/bc/adt/repository/informationsystem/usageReferences",
-    params: {
-      "uri": uri,
-      "ris_request_type": "usageReferences"
-    },
-    headers: {
-      "Content-Type": "application/vnd.sap.adt.repository.usagereferences.request.v1+xml",
-      "Accept": "application/vnd.sap.adt.repository.usagereferences.result.v1+xml"
-    },
-    body
-  });
-  if (requestErr) {
-    return err(requestErr);
-  }
-  if (!response.ok) {
-    const text2 = await response.text();
-    const errorMsg = extractError(text2);
-    return err(new Error(`Where-used query failed: ${errorMsg}`));
-  }
-  const text = await response.text();
-  const [dependencies, parseErr] = parseWhereUsed(text);
-  if (parseErr) {
-    return err(parseErr);
-  }
-  return ok(dependencies);
-}
-function parseWhereUsed(xml) {
-  const [doc, parseErr] = safeParseXml(xml);
-  if (parseErr) {
-    return err(parseErr);
-  }
-  const dependencies = [];
-  const referencedObjects = doc.getElementsByTagNameNS(
-    "http://www.sap.com/adt/ris/usageReferences",
-    "referencedObject"
-  );
-  for (let i = 0; i < referencedObjects.length; i++) {
-    const refObj = referencedObjects[i];
-    if (!refObj) continue;
-    const adtObject = refObj.getElementsByTagNameNS(
-      "http://www.sap.com/adt/ris/usageReferences",
-      "adtObject"
-    )[0];
-    if (!adtObject) continue;
-    const name = adtObject.getAttributeNS("http://www.sap.com/adt/core", "name") || adtObject.getAttribute("adtcore:name");
-    const type = adtObject.getAttributeNS("http://www.sap.com/adt/core", "type") || adtObject.getAttribute("adtcore:type");
-    if (!name || !type) continue;
-    const config = getConfigByType(type);
-    if (!config) continue;
-    const packageRef = adtObject.getElementsByTagNameNS("http://www.sap.com/adt/core", "packageRef")[0];
-    const packageName = packageRef ? packageRef.getAttributeNS("http://www.sap.com/adt/core", "name") || packageRef.getAttribute("adtcore:name") : "";
-    dependencies.push({
-      name,
-      extension: config.extension,
-      package: packageName || "",
-      usageType: "reference"
-    });
-  }
-  return ok(dependencies);
-}
-
 // src/core/adt/transports/createTransport.ts
 async function createTransport(client, config) {
   const body = dictToAbapXml({
@@ -2867,16 +3084,7 @@ async function activate(state, requestor, objects) {
 // src/client/methods/craud/delete.ts
 async function deleteObjects(state, requestor, objects, transport) {
   if (!state.session) return err(new Error("Not logged in"));
-  for (const obj of objects) {
-    const [lockHandle, lockErr] = await lockObject(requestor, obj);
-    if (lockErr) return err(lockErr);
-    const [, deleteErr] = await deleteObject(requestor, obj, lockHandle, transport);
-    if (deleteErr) {
-      await unlockObject(requestor, obj, lockHandle);
-      return err(deleteErr);
-    }
-  }
-  return ok(void 0);
+  return multiDeleteObjects(requestor, objects, transport);
 }
 
 // src/client/methods/craud/checkSyntax.ts
@@ -2909,6 +3117,12 @@ async function getTransports2(state, requestor, packageName) {
   return getTransports(requestor, packageName);
 }
 
+// src/client/methods/discovery/getInactiveObjects.ts
+async function getInactiveObjects2(state, requestor) {
+  if (!state.session) return err(new Error("Not logged in"));
+  return getInactiveObjects(requestor);
+}
+
 // src/client/methods/preview/previewData.ts
 async function previewData2(state, requestor, query) {
   if (!state.session) return err(new Error("Not logged in"));
@@ -3318,6 +3532,9 @@ var ADTClientImpl = class {
   async getTransports(packageName) {
     return getTransports2(this.state, this.requestor, packageName);
   }
+  async getInactiveObjects() {
+    return getInactiveObjects2(this.state, this.requestor);
+  }
   // --- Data Preview ---
   async previewData(query) {
     return previewData2(this.state, this.requestor, query);