catalyst-relay 0.5.1 → 0.5.3

package/dist/index.mjs

@@ -839,6 +839,12 @@ function extractCsrfToken(headers) {
 
 // src/core/utils/logging.ts
 var isActive = false;
+function activateLogging() {
+  isActive = true;
+}
+function deactivateLogging() {
+  isActive = false;
+}
 function debug(message) {
   if (isActive) {
     console.log(`[DEBUG] ${message}`);
@@ -1061,16 +1067,22 @@ function exportSessionState(ctx, ssoCerts) {
 // src/client/methods/session/importSessionState.ts
 var DEFAULT_REFRESH_INTERVAL2 = 30 * 60 * 1e3;
 async function importSessionState(ctx, state, setSsoCerts) {
+  debug(`importSessionState: starting import`);
   if (state.session.expiresAt <= Date.now()) {
+    debug(`importSessionState: session expired`);
     return err(new Error("Session has expired"));
   }
+  debug(`importSessionState: session expiry OK (expires at ${state.session.expiresAt})`);
   ctx.state.session = state.session;
   ctx.state.csrfToken = state.csrfToken;
+  debug(`importSessionState: restored session and CSRF token`);
   ctx.state.cookies.clear();
   for (const cookie of state.cookies) {
     ctx.state.cookies.set(cookie.name, cookie.value);
   }
+  debug(`importSessionState: restored ${state.cookies.length} cookies`);
   if (state.authType === "sso" && state.ssoCertPaths) {
+    debug(`importSessionState: loading SSO certs from ${state.ssoCertPaths.fullChainPath}`);
     try {
       const fs = await import("fs/promises");
       const [fullChain, key] = await Promise.all([
@@ -1078,32 +1090,52 @@ async function importSessionState(ctx, state, setSsoCerts) {
         fs.readFile(state.ssoCertPaths.keyPath, "utf-8")
       ]);
       setSsoCerts({ cert: fullChain, key });
+      debug(`importSessionState: SSO certs loaded successfully`);
     } catch (certErr) {
+      debug(`importSessionState: SSO cert load failed: ${certErr}`);
       return err(new Error(`Failed to load SSO certificates: ${certErr instanceof Error ? certErr.message : String(certErr)}`));
     }
   }
+  debug(`importSessionState: fetching fresh CSRF token...`);
   const [response, reqErr] = await ctx.request({
     method: "GET",
-    path: "/sap/bc/adt/compatibility/graph"
+    path: "/sap/bc/adt/compatibility/graph",
+    headers: {
+      [CSRF_TOKEN_HEADER]: FETCH_CSRF_TOKEN
+    }
   });
+  debug(`importSessionState: CSRF fetch completed`);
   if (reqErr) {
+    debug(`importSessionState: CSRF fetch error: ${reqErr.message}`);
     ctx.state.session = null;
     ctx.state.csrfToken = null;
     ctx.state.cookies.clear();
     return err(new Error(`Session validation failed: ${reqErr.message}`));
   }
   if (!response.ok) {
+    debug(`importSessionState: CSRF fetch failed with status ${response.status}`);
     ctx.state.session = null;
     ctx.state.csrfToken = null;
     ctx.state.cookies.clear();
     return err(new Error(`Session validation failed with status ${response.status}`));
   }
+  const newToken = extractCsrfToken(response.headers);
+  if (!newToken) {
+    debug(`importSessionState: no CSRF token in response headers`);
+    ctx.state.session = null;
+    ctx.state.csrfToken = null;
+    ctx.state.cookies.clear();
+    return err(new Error("Session validation failed: no CSRF token returned"));
+  }
+  ctx.state.csrfToken = newToken;
+  debug(`importSessionState: new CSRF token obtained: ${newToken.substring(0, 20)}...`);
   const autoRefresh = ctx.state.config.autoRefresh ?? { enabled: true };
   if (autoRefresh.enabled) {
     const interval = autoRefresh.intervalMs ?? DEFAULT_REFRESH_INTERVAL2;
     ctx.startAutoRefresh(interval);
     debug(`Auto-refresh started with ${interval}ms interval (after import)`);
   }
+  debug(`importSessionState: import complete`);
   return ok(true);
 }
 
@@ -1145,6 +1177,14 @@ var OBJECT_CONFIG_MAP = {
     dpEndpoint: "ddic",
     dpParam: "ddicEntityName"
   },
+  "astablds": {
+    endpoint: "ddic/structures",
+    nameSpace: 'xmlns:blue="http://www.sap.com/wbobj/blue"',
+    rootName: "blue:blueSource",
+    type: "STRU/D",
+    label: "Structure" /* STRUCTURE */,
+    extension: "astablds"
+  },
   "asprog": {
     endpoint: "programs/programs",
     nameSpace: 'xmlns:program="http://www.sap.com/adt/programs/programs"',
@@ -1461,8 +1501,201 @@ function extractActivationErrors(objects, xml, _extension) {
   return ok(results);
 }
 
+// src/core/adt/craud/syntaxCheck.ts
+async function checkSyntax(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 syntax check"));
+    }
+  }
+  const sources = /* @__PURE__ */ new Map();
+  for (const obj of objects) {
+    const [result, readErr] = await readObject(client, obj);
+    if (readErr) return err(new Error(`Failed to read ${obj.name}: ${readErr.message}`));
+    sources.set(obj.name.toLowerCase(), result.content);
+  }
+  const objectRefs = objects.map((obj) => {
+    const uri = `/sap/bc/adt/${config.endpoint}/${obj.name.toLowerCase()}`;
+    const sourceUri = `${uri}/source/main`;
+    const content = sources.get(obj.name.toLowerCase()) ?? "";
+    const encoded = Buffer.from(content).toString("base64");
+    return `<chkrun:checkObject adtcore:uri="${uri}" chkrun:version="active">
+        <chkrun:artifacts>
+            <chkrun:artifact chkrun:contentType="text/plain; charset=utf-8" chkrun:uri="${sourceUri}">
+                <chkrun:content>${encoded}</chkrun:content>
+            </chkrun:artifact>
+        </chkrun:artifacts>
+    </chkrun:checkObject>`;
+  }).join("\n    ");
+  const body = `<?xml version="1.0" encoding="UTF-8"?>
+<chkrun:checkObjectList xmlns:chkrun="http://www.sap.com/adt/checkrun"
+                        xmlns:adtcore="http://www.sap.com/adt/core">
+    ${objectRefs}
+</chkrun:checkObjectList>`;
+  const [response, requestErr] = await client.request({
+    method: "POST",
+    path: "/sap/bc/adt/checkruns",
+    params: {
+      "reporters": "abapCheckRun"
+    },
+    headers: {
+      "Content-Type": "application/vnd.sap.adt.checkobjects+xml",
+      "Accept": "application/vnd.sap.adt.checkmessages+xml"
+    },
+    body
+  });
+  if (requestErr) {
+    return err(requestErr);
+  }
+  const text = await response.text();
+  debug(`Syntax check response status: ${response.status}`);
+  debug(`Syntax check response: ${text.substring(0, 500)}`);
+  if (!response.ok) {
+    const errorMsg = extractError(text);
+    return err(new Error(`Syntax check failed: ${errorMsg}`));
+  }
+  const [results, parseErr] = extractCheckMessages(objects, text);
+  if (parseErr) {
+    return err(parseErr);
+  }
+  return ok(results);
+}
+function extractCheckMessages(objects, xml) {
+  const [doc, parseErr] = safeParseXml(xml);
+  if (parseErr) {
+    return err(parseErr);
+  }
+  const messageMap = /* @__PURE__ */ new Map();
+  objects.forEach((obj) => messageMap.set(obj.name.toLowerCase(), []));
+  let msgElements = doc.getElementsByTagName("chkrun:checkMessage");
+  if (msgElements.length === 0) {
+    msgElements = doc.getElementsByTagName("checkMessage");
+  }
+  const startRegex = /#start=(\d+),(\d+)/;
+  for (let i = 0; i < msgElements.length; i++) {
+    const msg = msgElements[i];
+    if (!msg) continue;
+    const type = msg.getAttribute("chkrun:type") ?? msg.getAttribute("type");
+    if (!type) continue;
+    const uri = msg.getAttribute("chkrun:uri") ?? msg.getAttribute("uri") ?? "";
+    let line;
+    let column;
+    const match = startRegex.exec(uri);
+    if (match && match[1] && match[2]) {
+      line = parseInt(match[1], 10);
+      column = parseInt(match[2], 10);
+    }
+    const matchingObj = objects.find(
+      (obj) => uri.toLowerCase().includes(obj.name.toLowerCase())
+    );
+    if (!matchingObj) continue;
+    const text = msg.getAttribute("chkrun:shortText") ?? msg.getAttribute("shortText");
+    if (!text) continue;
+    const message = {
+      severity: type === "E" ? "error" : type === "W" ? "warning" : "info",
+      text,
+      ...line !== void 0 && { line },
+      ...column !== void 0 && { column }
+    };
+    const messages = messageMap.get(matchingObj.name.toLowerCase()) || [];
+    messages.push(message);
+    messageMap.set(matchingObj.name.toLowerCase(), messages);
+  }
+  const results = objects.map((obj) => {
+    const messages = messageMap.get(obj.name.toLowerCase()) || [];
+    const hasErrors = messages.some((m) => m.severity === "error");
+    return {
+      name: obj.name,
+      extension: obj.extension,
+      status: hasErrors ? "error" : messages.length > 0 ? "warning" : "success",
+      messages
+    };
+  });
+  return ok(results);
+}
+
+// src/core/adt/discovery/tree/packageStats.ts
+function constructPackageStatsBody(packageNames) {
+  const names = packageNames.length === 1 ? [...packageNames, "SRIS_TEST_DATA_VFS_EMPTY"] : packageNames;
+  const values = names.map((name) => `    <vfs:value>${name}</vfs:value>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<vfs:virtualFoldersRequest xmlns:vfs="http://www.sap.com/adt/ris/virtualFolders" objectSearchPattern="*">
+  <vfs:preselection facet="package">
+${values}
+  </vfs:preselection>
+  <vfs:facetorder>
+    <vfs:facet>package</vfs:facet>
+    <vfs:facet>group</vfs:facet>
+    <vfs:facet>type</vfs:facet>
+  </vfs:facetorder>
+</vfs:virtualFoldersRequest>`;
+}
+function parsePackageStats(xml) {
+  const [doc, parseErr] = safeParseXml(xml);
+  if (parseErr) return [];
+  const packages = [];
+  const virtualFolders = doc.getElementsByTagName("vfs:virtualFolder");
+  for (let i = 0; i < virtualFolders.length; i++) {
+    const vf = virtualFolders[i];
+    if (!vf) continue;
+    const facet = vf.getAttribute("facet")?.toUpperCase();
+    if (facet !== "PACKAGE") continue;
+    const name = vf.getAttribute("name");
+    if (!name) continue;
+    const countAttr = vf.getAttribute("counter");
+    const count = countAttr ? parseInt(countAttr, 10) : 0;
+    const description = vf.getAttribute("text");
+    const pkg = {
+      name,
+      numContents: count
+    };
+    if (description) pkg.description = description;
+    packages.push(pkg);
+  }
+  return packages;
+}
+async function getPackageStats(client, packageNames) {
+  const isSingle = typeof packageNames === "string";
+  const names = isSingle ? [packageNames] : packageNames;
+  if (names.length === 0) {
+    return ok([]);
+  }
+  const body = constructPackageStatsBody(names);
+  const [response, requestErr] = await client.request({
+    method: "POST",
+    path: "/sap/bc/adt/repository/informationsystem/virtualfolders/contents",
+    headers: {
+      "Content-Type": "application/vnd.sap.adt.repository.virtualfolders.request.v1+xml",
+      "Accept": "application/vnd.sap.adt.repository.virtualfolders.result.v1+xml"
+    },
+    body
+  });
+  if (requestErr) return err(requestErr);
+  if (!response.ok) {
+    const text = await response.text();
+    const errorMsg = extractError(text);
+    return err(new Error(`Package stats fetch failed: ${errorMsg}`));
+  }
+  const xml = await response.text();
+  const packages = parsePackageStats(xml).filter((pkg) => pkg.name !== "SRIS_TEST_DATA_VFS_EMPTY");
+  if (isSingle) {
+    if (packages.length === 0) {
+      return err(new Error(`Package ${packageNames} not found`));
+    }
+    return ok(packages[0]);
+  }
+  return ok(packages);
+}
+
 // src/core/adt/discovery/packages.ts
-async function getPackages(client, filter = "*") {
+async function getPackages(client, options = {}) {
+  const { filter = "*", includeDescriptions = false } = options;
   const params = new URLSearchParams([
     ["operation", "quickSearch"],
     ["query", filter],
@@ -1486,18 +1719,31 @@ async function getPackages(client, filter = "*") {
   if (parseErr) {
     return err(parseErr);
   }
-  const packages = [];
+  const packageNames = [];
   const objectRefs = doc.getElementsByTagNameNS("http://www.sap.com/adt/core", "objectReference");
   for (let i = 0; i < objectRefs.length; i++) {
     const obj = objectRefs[i];
     if (!obj) return err(new Error("Invalid object reference in package search results"));
     const name = obj.getAttributeNS("http://www.sap.com/adt/core", "name") || obj.getAttribute("adtcore:name");
-    const description = obj.getAttributeNS("http://www.sap.com/adt/core", "description") || obj.getAttribute("adtcore:description");
     if (!name) return err(new Error("Package name missing in object reference"));
+    packageNames.push(name);
+  }
+  if (packageNames.length === 0) return ok([]);
+  if (!includeDescriptions) return ok(packageNames.map((name) => ({ name })));
+  const [stats, statsErr] = await getPackageStats(client, packageNames);
+  if (statsErr) {
+    return ok(packageNames.map((name) => ({ name })));
+  }
+  const descriptionMap = /* @__PURE__ */ new Map();
+  for (const stat2 of stats) {
+    if (stat2.description) descriptionMap.set(stat2.name, stat2.description);
+  }
+  const packages = packageNames.map((name) => {
     const pkg = { name };
+    const description = descriptionMap.get(name);
     if (description) pkg.description = description;
-    packages.push(pkg);
-  }
+    return pkg;
+  });
   return ok(packages);
 }
 
@@ -1737,79 +1983,6 @@ async function getTree(client, query = {}) {
   return ok(result);
 }
 
-// src/core/adt/discovery/tree/packageStats.ts
-function constructPackageStatsBody(packageNames) {
-  const names = packageNames.length === 1 ? [...packageNames, "SRIS_TEST_DATA_VFS_EMPTY"] : packageNames;
-  const values = names.map((name) => `    <vfs:value>${name}</vfs:value>`).join("\n");
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<vfs:virtualFoldersRequest xmlns:vfs="http://www.sap.com/adt/ris/virtualFolders" objectSearchPattern="*">
-  <vfs:preselection facet="package">
-${values}
-  </vfs:preselection>
-  <vfs:facetorder>
-    <vfs:facet>package</vfs:facet>
-    <vfs:facet>group</vfs:facet>
-    <vfs:facet>type</vfs:facet>
-  </vfs:facetorder>
-</vfs:virtualFoldersRequest>`;
-}
-function parsePackageStats(xml) {
-  const [doc, parseErr] = safeParseXml(xml);
-  if (parseErr) return [];
-  const packages = [];
-  const virtualFolders = doc.getElementsByTagName("vfs:virtualFolder");
-  for (let i = 0; i < virtualFolders.length; i++) {
-    const vf = virtualFolders[i];
-    if (!vf) continue;
-    const facet = vf.getAttribute("facet")?.toUpperCase();
-    if (facet !== "PACKAGE") continue;
-    const name = vf.getAttribute("name");
-    if (!name) continue;
-    const countAttr = vf.getAttribute("counter");
-    const count = countAttr ? parseInt(countAttr, 10) : 0;
-    const description = vf.getAttribute("text");
-    const pkg = {
-      name,
-      numContents: count
-    };
-    if (description) pkg.description = description;
-    packages.push(pkg);
-  }
-  return packages;
-}
-async function getPackageStats(client, packageNames) {
-  const isSingle = typeof packageNames === "string";
-  const names = isSingle ? [packageNames] : packageNames;
-  if (names.length === 0) {
-    return ok([]);
-  }
-  const body = constructPackageStatsBody(names);
-  const [response, requestErr] = await client.request({
-    method: "POST",
-    path: "/sap/bc/adt/repository/informationsystem/virtualfolders/contents",
-    headers: {
-      "Content-Type": "application/vnd.sap.adt.repository.virtualfolders.request.v1+xml",
-      "Accept": "application/vnd.sap.adt.repository.virtualfolders.result.v1+xml"
-    },
-    body
-  });
-  if (requestErr) return err(requestErr);
-  if (!response.ok) {
-    const text = await response.text();
-    const errorMsg = extractError(text);
-    return err(new Error(`Package stats fetch failed: ${errorMsg}`));
-  }
-  const xml = await response.text();
-  const packages = parsePackageStats(xml).filter((pkg) => pkg.name !== "SRIS_TEST_DATA_VFS_EMPTY");
-  if (isSingle) {
-    if (packages.length === 0) {
-      return err(new Error(`Package ${packageNames} not found`));
-    }
-    return ok(packages[0]);
-  }
-  return ok(packages);
-}
-
 // src/core/adt/transports/transports.ts
 async function getTransports(client, packageName) {
   const contentType = "application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.transport.service.checkData";
@@ -2465,10 +2638,16 @@ async function deleteObjects(state, requestor, objects, transport) {
   return ok(void 0);
 }
 
+// src/client/methods/craud/checkSyntax.ts
+async function checkSyntax2(state, requestor, objects) {
+  if (!state.session) return err(new Error("Not logged in"));
+  return checkSyntax(requestor, objects);
+}
+
 // src/client/methods/discovery/getPackages.ts
-async function getPackages2(state, requestor, filter) {
+async function getPackages2(state, requestor, options) {
   if (!state.session) return err(new Error("Not logged in"));
-  return getPackages(requestor, filter);
+  return getPackages(requestor, options);
 }
 
 // src/client/methods/discovery/getTree.ts
@@ -2573,6 +2752,7 @@ function createAutoRefresh(getSession, refreshSession3) {
           debug(`Auto-refresh failed: ${refreshErr.message}`);
         }
       }, intervalMs);
+      timer.unref();
     },
     stop() {
       if (timer) {
@@ -2860,12 +3040,15 @@ var ADTClientImpl = class {
   async activate(objects) {
     return activate(this.state, this.requestor, objects);
   }
+  async checkSyntax(objects) {
+    return checkSyntax2(this.state, this.requestor, objects);
+  }
   async delete(objects, transport) {
     return deleteObjects(this.state, this.requestor, objects, transport);
   }
   // --- Discovery ---
-  async getPackages(filter) {
-    return getPackages2(this.state, this.requestor, filter);
+  async getPackages(options) {
+    return getPackages2(this.state, this.requestor, options);
   }
   async getTree(query) {
     return getTree2(this.state, this.requestor, query);
@@ -2917,8 +3100,10 @@ function createClient(config) {
   return ok(new ADTClientImpl(config));
 }
 export {
+  activateLogging,
   buildSQLQuery,
   createClient,
+  deactivateLogging,
   err,
   ok
 };