catalyst-relay 0.6.4 → 0.6.6

package/dist/index.mjs

@@ -2052,6 +2052,192 @@ function extractActivationErrors(objects, xml) {
   return ok(results);
 }
 
+// src/core/adt/craud/apirelease/helpers.ts
+var DDLS_ENDPOINT = "ddic/ddl/sources";
+var CONTRACT_PATH = "c1";
+var CONTRACT_ELEMENT = "ars:c1Release";
+var APIRELEASE_MEDIA_TYPE = "application/vnd.sap.adt.apirelease.v10+xml";
+var APIRELEASE_VALIDATION_CONTENT_TYPE = "application/vnd.sap.adt.apireleasecontractvalidation+xml";
+var APIRELEASE_VALIDATION_ACCEPT = "application/vnd.sap.adt.apireleasecontractvalidation+xml, application/vnd.sap.adt.apireleasecontractvalidation.v2+xml";
+function buildReleasableUri(name) {
+  return `/sap/bc/adt/${DDLS_ENDPOINT}/${name.toLowerCase()}`;
+}
+function buildApiReleasePath(name) {
+  return `/sap/bc/adt/apireleases/${encodeURIComponent(buildReleasableUri(name))}`;
+}
+function buildContractPath(name) {
+  return `${buildApiReleasePath(name)}/${CONTRACT_PATH}`;
+}
+function buildValidationRunPath(name) {
+  return `${buildContractPath(name)}/validationrun`;
+}
+function buildC1ReleaseBody(status) {
+  return `<?xml version="1.0" encoding="UTF-8"?><ars:apiRelease xmlns:ars="http://www.sap.com/adt/ars">
+  <ars:c1Release ars:comment="" ars:contract="C1" ars:createAuthValues="false" ars:featureToggle="" ars:useInKeyUserApps="true" ars:useInSAPCloudPlatform="true">
+    <ars:status ars:state="${status}"/>
+    <ars:useConceptAsSuccessor>false</ars:useConceptAsSuccessor>
+    <ars:successors/>
+    <ars:successorConceptName/>
+  </ars:c1Release>
+  <ars:apiCatalogData ars:isAnyAssignmentPossible="false" ars:isAnyContractReleased="false">
+    <ars:ApiCatalogs/>
+  </ars:apiCatalogData>
+</ars:apiRelease>`;
+}
+function toStatus(state) {
+  return state;
+}
+function findContractElement(doc) {
+  const candidates = doc.getElementsByTagName(CONTRACT_ELEMENT);
+  for (let i = 0; i < candidates.length; i++) {
+    const el = candidates[i];
+    if (!el) continue;
+    if (el.getElementsByTagName("ars:status").length === 0) continue;
+    return el;
+  }
+  return null;
+}
+function parseReleaseState(xml, fallbackName) {
+  const [doc, parseErr] = safeParseXml(xml);
+  if (parseErr) return err(parseErr);
+  const contract = findContractElement(doc);
+  if (!contract) return err(new Error("apiRelease response missing C1 contract element"));
+  const statusEl = contract.getElementsByTagName("ars:status")[0];
+  const state = statusEl?.getAttribute("ars:state");
+  if (!state) return err(new Error("apiRelease response missing C1 status"));
+  const statusDescription = statusEl?.getAttribute("ars:stateDescription") ?? "";
+  const allowedTransitions = [];
+  const transitionsEl = contract.getElementsByTagName("ars:stateTransitions")[0];
+  if (transitionsEl) {
+    const transitionStatuses = transitionsEl.getElementsByTagName("ars:status");
+    for (let i = 0; i < transitionStatuses.length; i++) {
+      const transitionState = transitionStatuses[i]?.getAttribute("ars:state");
+      if (transitionState) allowedTransitions.push(toStatus(transitionState));
+    }
+  }
+  const releasable = doc.getElementsByTagName("ars:releasableObject")[0];
+  const name = releasable?.getAttribute("adtcore:name") ?? fallbackName;
+  const uri = releasable?.getAttribute("adtcore:uri") ?? buildReleasableUri(fallbackName);
+  const result = {
+    name,
+    uri,
+    status: toStatus(state),
+    statusDescription,
+    released: state === "RELEASED",
+    allowedTransitions
+  };
+  const changedBy = contract.getAttribute("adtcore:changedBy");
+  if (changedBy) result.changedBy = changedBy;
+  const changedAt = contract.getAttribute("adtcore:changedAt");
+  if (changedAt) result.changedAt = changedAt;
+  return ok(result);
+}
+function parseValidationMessages(xml) {
+  const [doc, parseErr] = safeParseXml(xml);
+  if (parseErr) return [];
+  const messages = [];
+  const elements = doc.getElementsByTagName("ars:validationMessage");
+  for (let i = 0; i < elements.length; i++) {
+    const el = elements[i];
+    if (!el) continue;
+    const text = el.getAttribute("text");
+    if (!text) continue;
+    const message = {
+      severity: mapSeverity(el.getAttribute("type")),
+      text
+    };
+    const msgid = el.getAttribute("msgid");
+    if (msgid) message.msgid = msgid;
+    const msgno = el.getAttribute("msgno");
+    if (msgno) message.msgno = msgno;
+    messages.push(message);
+  }
+  return messages;
+}
+function collectErrors(messages) {
+  return messages.filter((m) => m.severity === "error");
+}
+function mapSeverity(type) {
+  if (type === "E" || type === "A" || type === "X") return "error";
+  if (type === "W") return "warning";
+  return "info";
+}
+
+// src/core/adt/craud/apirelease/getState.ts
+async function getApiReleaseState(client, objectName) {
+  const [response, requestErr] = await client.request({
+    method: "GET",
+    path: buildApiReleasePath(objectName),
+    headers: { "Accept": APIRELEASE_MEDIA_TYPE }
+  });
+  const [text, checkErr] = await checkResponse(
+    response,
+    requestErr,
+    `Failed to read API release state for ${objectName}`
+  );
+  if (checkErr) return err(checkErr);
+  const [state, parseErr] = parseReleaseState(text, objectName);
+  if (parseErr) return err(parseErr);
+  return ok(state);
+}
+
+// src/core/adt/craud/apirelease/release.ts
+async function releaseApi(client, objectName, transport) {
+  return setApiReleaseState(client, objectName, "RELEASED", transport);
+}
+async function unreleaseApi(client, objectName, transport) {
+  return setApiReleaseState(client, objectName, "NOT_RELEASED", transport);
+}
+async function setApiReleaseState(client, objectName, status, transport) {
+  const body = buildC1ReleaseBody(status);
+  const [validationRes, validationReqErr] = await client.request({
+    method: "POST",
+    path: buildValidationRunPath(objectName),
+    headers: {
+      "Content-Type": APIRELEASE_VALIDATION_CONTENT_TYPE,
+      "Accept": APIRELEASE_VALIDATION_ACCEPT
+    },
+    body
+  });
+  const [validationText, validationCheckErr] = await checkResponse(
+    validationRes,
+    validationReqErr,
+    `API release validation failed for ${objectName}`
+  );
+  if (validationCheckErr) return err(validationCheckErr);
+  const messages = parseValidationMessages(validationText);
+  const errors = collectErrors(messages);
+  if (errors.length > 0) {
+    const detail = errors.map((e) => e.text).join("; ");
+    return err(new Error(`API release validation failed for ${objectName}: ${detail}`));
+  }
+  const params = {};
+  if (transport) params["request"] = transport;
+  const [putRes, putReqErr] = await client.request({
+    method: "PUT",
+    path: buildContractPath(objectName),
+    params,
+    headers: {
+      "Content-Type": APIRELEASE_MEDIA_TYPE,
+      "Accept": APIRELEASE_MEDIA_TYPE
+    },
+    body
+  });
+  const [putText, putCheckErr] = await checkResponse(
+    putRes,
+    putReqErr,
+    `Failed to set API release state for ${objectName}`
+  );
+  if (putCheckErr) return err(putCheckErr);
+  const [state, parseErr] = parseReleaseState(putText, objectName);
+  if (parseErr) return err(parseErr);
+  return ok({
+    name: state.name,
+    status: state.status,
+    messages
+  });
+}
+
 // src/core/adt/craud/syntaxCheck.ts
 async function checkSyntax(client, objects) {
   if (objects.length === 0) {
@@ -3884,6 +4070,24 @@ async function deleteServiceBinding2(state, requestor, bindingName, transport) {
   return deleteServiceBinding(requestor, bindingName, transport);
 }
 
+// src/client/methods/apirelease/getApiReleaseState.ts
+async function getApiReleaseState2(state, requestor, objectName) {
+  if (!state.session) return err(new Error("Not logged in"));
+  return getApiReleaseState(requestor, objectName);
+}
+
+// src/client/methods/apirelease/releaseApi.ts
+async function releaseApi2(state, requestor, objectName, transport) {
+  if (!state.session) return err(new Error("Not logged in"));
+  return releaseApi(requestor, objectName, transport);
+}
+
+// src/client/methods/apirelease/unreleaseApi.ts
+async function unreleaseApi2(state, requestor, objectName, transport) {
+  if (!state.session) return err(new Error("Not logged in"));
+  return unreleaseApi(requestor, objectName, transport);
+}
+
 // src/client/methods/internal/cookies.ts
 function storeCookies(cookies, response) {
   const setCookieHeader = response.headers.get("set-cookie");
@@ -4076,9 +4280,12 @@ async function executeRequest(deps, options, selfRequest) {
     }
     if (response.status === 500) {
       const text = await response.text();
-      const [, resetErr] = await sessionReset(state, selfRequest);
-      if (resetErr) {
-        return err(new Error(`Session reset failed: ${resetErr.message}`));
+      const isSessionError = /session/i.test(text) && /(timed out|expired|no longer exists|not found)/i.test(text);
+      if (isSessionError && config.auth.type !== "saml") {
+        const [, resetErr] = await sessionReset(state, selfRequest);
+        if (resetErr) {
+          debugError(`Session reset after 500 failed: ${resetErr.message}`);
+        }
       }
       return ok(new Response(text, {
         status: response.status,
@@ -4274,6 +4481,16 @@ var ADTClientImpl = class {
   async deleteServiceBinding(bindingName, transport) {
     return deleteServiceBinding2(this.state, this.requestor, bindingName, transport);
   }
+  // --- API Release ---
+  async getApiReleaseState(objectName) {
+    return getApiReleaseState2(this.state, this.requestor, objectName);
+  }
+  async releaseApi(objectName, transport) {
+    return releaseApi2(this.state, this.requestor, objectName, transport);
+  }
+  async unreleaseApi(objectName, transport) {
+    return unreleaseApi2(this.state, this.requestor, objectName, transport);
+  }
   // --- Configuration ---
   getObjectConfig() {
     return getObjectConfig();