sap-adt-mcp 0.7.1

package/src/object-create.js

@@ -0,0 +1,244 @@
+// Build the POST request needed to create a new ABAP object via ADT.
+//
+// Returns { path, contentType, body } so the server handler just dispatches it.
+//
+// Each ADT object kind has its own collection endpoint, content-type, and XML
+// shape. The shapes here cover the common modern (NW 7.5x+ / S/4) on-prem
+// surface; older systems may reject some content-types. If yours does, fall
+// back to adt_request and craft the POST manually.
+
+import { normalizeType } from "./object-uris.js";
+
+export function buildCreateRequest({
+  type,
+  name,
+  package: pkg,
+  description,
+  group,
+  programType,
+  responsible,
+}) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Object create: `name` is required");
+  }
+  if (!pkg || typeof pkg !== "string") {
+    throw new Error("Object create: `package` is required");
+  }
+  const t = normalizeType(type);
+  const upperName = name.toUpperCase();
+  const upperPkg = pkg.toUpperCase();
+  const desc = (description ?? upperName).slice(0, 60);
+  const respAttr = responsible
+    ? ` adtcore:responsible="${escapeXml(responsible.toUpperCase())}"`
+    : "";
+
+  switch (t) {
+    case "PROG":
+      return {
+        path: "/sap/bc/adt/programs/programs",
+        contentType: "application/vnd.sap.adt.programs.programs.v2+xml",
+        body: xmlDecl() +
+          `<program:abapProgram xmlns:program="http://www.sap.com/adt/programs/programs"` +
+          ` xmlns:adtcore="http://www.sap.com/adt/core"` +
+          ` adtcore:name="${escapeXml(upperName)}" adtcore:type="PROG/P"` +
+          ` adtcore:description="${escapeXml(desc)}"${respAttr}` +
+          // programType is whitelisted to known ADT values; anything else
+          // would either be rejected by SAP or, if it contained a stray
+          // double-quote, let the caller close the attribute and inject
+          // arbitrary XML attributes / elements (e.g. a second packageRef
+          // pointing at a different package than the one the user asked for).
+          ` program:programType="${escapeXml(validateProgramType(programType))}">` +
+          packageRef(upperPkg) +
+          `</program:abapProgram>`,
+      };
+
+    case "CLAS":
+      return {
+        path: "/sap/bc/adt/oo/classes",
+        contentType: "application/vnd.sap.adt.oo.classes.v3+xml",
+        body: xmlDecl() +
+          `<class:abapClass xmlns:class="http://www.sap.com/adt/oo/classes"` +
+          ` xmlns:adtcore="http://www.sap.com/adt/core"` +
+          ` adtcore:name="${escapeXml(upperName)}" adtcore:type="CLAS/OC"` +
+          ` adtcore:description="${escapeXml(desc)}"${respAttr}` +
+          ` class:final="true" class:visibility="public" class:abstract="false"` +
+          ` class:category="generalObjectType">` +
+          packageRef(upperPkg) +
+          `</class:abapClass>`,
+      };
+
+    case "INTF":
+      return {
+        path: "/sap/bc/adt/oo/interfaces",
+        contentType: "application/vnd.sap.adt.oo.interfaces.v2+xml",
+        body: xmlDecl() +
+          `<intf:abapInterface xmlns:intf="http://www.sap.com/adt/oo/interfaces"` +
+          ` xmlns:adtcore="http://www.sap.com/adt/core"` +
+          ` adtcore:name="${escapeXml(upperName)}" adtcore:type="INTF/OI"` +
+          ` adtcore:description="${escapeXml(desc)}"${respAttr}>` +
+          packageRef(upperPkg) +
+          `</intf:abapInterface>`,
+      };
+
+    case "INCL":
+      return {
+        path: "/sap/bc/adt/programs/includes",
+        contentType: "application/vnd.sap.adt.programs.includes.v2+xml",
+        body: xmlDecl() +
+          `<include:abapInclude xmlns:include="http://www.sap.com/adt/programs/includes"` +
+          ` xmlns:adtcore="http://www.sap.com/adt/core"` +
+          ` adtcore:name="${escapeXml(upperName)}" adtcore:type="PROG/I"` +
+          ` adtcore:description="${escapeXml(desc)}"${respAttr}>` +
+          packageRef(upperPkg) +
+          `</include:abapInclude>`,
+      };
+
+    case "FUGR":
+      return {
+        path: "/sap/bc/adt/functions/groups",
+        contentType: "application/vnd.sap.adt.functions.groups.v3+xml",
+        body: xmlDecl() +
+          `<group:abapFunctionGroup xmlns:group="http://www.sap.com/adt/functions/groups"` +
+          ` xmlns:adtcore="http://www.sap.com/adt/core"` +
+          ` adtcore:name="${escapeXml(upperName)}" adtcore:type="FUGR/F"` +
+          ` adtcore:description="${escapeXml(desc)}"${respAttr}>` +
+          packageRef(upperPkg) +
+          `</group:abapFunctionGroup>`,
+      };
+
+    case "FUGR/FF": {
+      if (!group) {
+        throw new Error(
+          "Function module create: `group` (function group name) is required"
+        );
+      }
+      const upperGroup = group.toUpperCase();
+      const lowerGroup = group.toLowerCase();
+      return {
+        path: `/sap/bc/adt/functions/groups/${encodeURIComponent(lowerGroup)}/fmodules`,
+        contentType: "application/vnd.sap.adt.functions.fmodules.v3+xml",
+        body: xmlDecl() +
+          `<fm:abapFunctionModule xmlns:fm="http://www.sap.com/adt/functions/fmodules"` +
+          ` xmlns:adtcore="http://www.sap.com/adt/core"` +
+          ` adtcore:name="${escapeXml(upperName)}" adtcore:type="FUGR/FF"` +
+          ` adtcore:description="${escapeXml(desc)}"${respAttr}>` +
+          `<fm:containerRef adtcore:uri="/sap/bc/adt/functions/groups/${escapeXml(lowerGroup)}"` +
+          ` adtcore:type="FUGR/F" adtcore:name="${escapeXml(upperGroup)}"/>` +
+          `</fm:abapFunctionModule>`,
+      };
+    }
+
+    case "DDLS":
+      return {
+        path: "/sap/bc/adt/ddic/ddl/sources",
+        contentType: "application/vnd.sap.adt.ddlsource.v2+xml",
+        body: xmlDecl() +
+          `<ddl:source xmlns:ddl="http://www.sap.com/adt/ddic/ddlsources"` +
+          ` xmlns:adtcore="http://www.sap.com/adt/core"` +
+          ` adtcore:name="${escapeXml(upperName)}" adtcore:type="DDLS/DF"` +
+          ` adtcore:description="${escapeXml(desc)}"${respAttr}>` +
+          packageRef(upperPkg) +
+          `</ddl:source>`,
+      };
+
+    case "DCLS":
+      return {
+        path: "/sap/bc/adt/acm/dcls",
+        contentType: "application/vnd.sap.adt.acm.dcls.v2+xml",
+        body: xmlDecl() +
+          `<dcl:source xmlns:dcl="http://www.sap.com/adt/acm/dcls"` +
+          ` xmlns:adtcore="http://www.sap.com/adt/core"` +
+          ` adtcore:name="${escapeXml(upperName)}" adtcore:type="DCLS/DL"` +
+          ` adtcore:description="${escapeXml(desc)}"${respAttr}>` +
+          packageRef(upperPkg) +
+          `</dcl:source>`,
+      };
+
+    case "DDLX":
+      return {
+        path: "/sap/bc/adt/ddic/ddlx/sources",
+        contentType: "application/vnd.sap.adt.ddlxsource.v2+xml",
+        body: xmlDecl() +
+          `<ddlx:source xmlns:ddlx="http://www.sap.com/adt/ddic/ddlxsources"` +
+          ` xmlns:adtcore="http://www.sap.com/adt/core"` +
+          ` adtcore:name="${escapeXml(upperName)}" adtcore:type="DDLX/EX"` +
+          ` adtcore:description="${escapeXml(desc)}"${respAttr}>` +
+          packageRef(upperPkg) +
+          `</ddlx:source>`,
+      };
+
+    case "BDEF":
+      return {
+        path: "/sap/bc/adt/bo/behaviordefinitions",
+        contentType: "application/vnd.sap.adt.bo.bdef.v2+xml",
+        body: xmlDecl() +
+          `<bdef:behaviorDefinition xmlns:bdef="http://www.sap.com/adt/bo/bdef"` +
+          ` xmlns:adtcore="http://www.sap.com/adt/core"` +
+          ` adtcore:name="${escapeXml(upperName)}" adtcore:type="BDEF/BO"` +
+          ` adtcore:description="${escapeXml(desc)}"${respAttr}>` +
+          packageRef(upperPkg) +
+          `</bdef:behaviorDefinition>`,
+      };
+
+    case "MSAG":
+      return {
+        path: "/sap/bc/adt/messageclasses",
+        contentType: "application/vnd.sap.adt.messageclass.v2+xml",
+        body: xmlDecl() +
+          `<msag:messageClass xmlns:msag="http://www.sap.com/adt/messageclasses"` +
+          ` xmlns:adtcore="http://www.sap.com/adt/core"` +
+          ` adtcore:name="${escapeXml(upperName)}" adtcore:type="MSAG/N"` +
+          ` adtcore:description="${escapeXml(desc)}"${respAttr}>` +
+          packageRef(upperPkg) +
+          `</msag:messageClass>`,
+      };
+
+    default:
+      throw new Error(
+        `Object create not supported for type: ${type} (normalized: ${t}). ` +
+          "Use adt_request to POST to the relevant ADT collection endpoint."
+      );
+  }
+}
+
+function xmlDecl() {
+  return `<?xml version="1.0" encoding="UTF-8"?>`;
+}
+
+function packageRef(pkg) {
+  return `<adtcore:packageRef adtcore:name="${escapeXml(pkg)}"/>`;
+}
+
+function escapeXml(s) {
+  return String(s)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+// SAP's published ADT values for program:programType. Anything outside this
+// set is rejected so a caller can't smuggle XML attribute terminators into
+// the attribute value (defense in depth — escapeXml at the call site already
+// handles quoting).
+const ALLOWED_PROGRAM_TYPES = new Set([
+  "executableProgram",
+  "modulePool",
+  "subroutinePool",
+  "functionGroup",
+  "interfacePool",
+  "classPool",
+  "typeGroup",
+  "include",
+]);
+
+function validateProgramType(programType) {
+  if (programType == null) return "executableProgram";
+  if (typeof programType !== "string" || !ALLOWED_PROGRAM_TYPES.has(programType)) {
+    throw new Error(
+      `Invalid programType: ${programType}. Allowed: ${[...ALLOWED_PROGRAM_TYPES].join(", ")}`
+    );
+  }
+  return programType;
+}

package/src/object-references.js

@@ -0,0 +1,28 @@
+// Parse <adtcore:objectReference .../> entries that appear in many ADT responses
+// (search results, where-used, transport contents, etc.).
+
+const REF_RE = /<adtcore:objectReference\b([\s\S]*?)\/>/gi;
+const ATTR_RE = /(\w[\w:-]*)\s*=\s*"([^"]*)"/g;
+
+export function parseObjectReferences(xml) {
+  if (typeof xml !== "string") return [];
+  const out = [];
+  for (const m of xml.matchAll(REF_RE)) {
+    const attrs = {};
+    for (const a of m[1].matchAll(ATTR_RE)) {
+      const key = a[1].replace(/^adtcore:/, "");
+      attrs[key] = decodeEntities(a[2]);
+    }
+    if (attrs.name || attrs.uri) out.push(attrs);
+  }
+  return out;
+}
+
+function decodeEntities(s) {
+  return s
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, "&");
+}

package/src/object-uris.js

@@ -0,0 +1,156 @@
+// Map ABAP object identifiers (name + type) to ADT URIs.
+//
+// Accepts either friendly type aliases (program / class / interface / ...) or
+// raw TADIR-style codes (PROG / CLAS / INTF / FUGR / FUGR/FF / INCL).
+// Function modules need a function group: pass `{ type: "function", name, group }`.
+//
+// Object URI = the ADT object resource (used for lock/unlock and metadata GET).
+// Source URI = the editable source document (used for source GET/PUT).
+// Some objects (classes) have multiple source includes — `include` selects which.
+
+const TYPE_ALIASES = {
+  program: "PROG",
+  prog: "PROG",
+  report: "PROG",
+  include: "INCL",
+  incl: "INCL",
+  class: "CLAS",
+  clas: "CLAS",
+  interface: "INTF",
+  intf: "INTF",
+  function: "FUGR/FF",
+  functionmodule: "FUGR/FF",
+  fm: "FUGR/FF",
+  functiongroup: "FUGR",
+  fugr: "FUGR",
+  table: "TABL",
+  tabl: "TABL",
+  structure: "TABL",
+  dataelement: "DTEL",
+  dtel: "DTEL",
+  domain: "DOMA",
+  doma: "DOMA",
+  cds: "DDLS",
+  ddls: "DDLS",
+  accesscontrol: "DCLS",
+  dcls: "DCLS",
+  metadataextension: "DDLX",
+  metadataext: "DDLX",
+  ddlx: "DDLX",
+  behaviordef: "BDEF",
+  behaviordefinition: "BDEF",
+  bdef: "BDEF",
+  servicedefinition: "SRVD",
+  servicedef: "SRVD",
+  srvd: "SRVD",
+  servicebinding: "SRVB",
+  srvb: "SRVB",
+  messageclass: "MSAG",
+  msag: "MSAG",
+};
+
+const CLASS_INCLUDES = {
+  main: "main",
+  definitions: "definitions",
+  defs: "definitions",
+  implementations: "implementations",
+  imps: "implementations",
+  macros: "macros",
+  testclasses: "testclasses",
+  tests: "testclasses",
+};
+
+export function normalizeType(input) {
+  if (typeof input !== "string" || input.length === 0) {
+    throw new Error("Object type is required");
+  }
+  const upper = input.toUpperCase();
+  if (upper.includes("/")) return upper;
+  const aliased = TYPE_ALIASES[input.toLowerCase()];
+  return aliased ?? upper;
+}
+
+export function objectUri({ type, name, group }) {
+  const t = normalizeType(type);
+  const n = name.toLowerCase();
+  switch (t) {
+    case "PROG":
+      return `/sap/bc/adt/programs/programs/${enc(n)}`;
+    case "INCL":
+      return `/sap/bc/adt/programs/includes/${enc(n)}`;
+    case "CLAS":
+      return `/sap/bc/adt/oo/classes/${enc(n)}`;
+    case "INTF":
+      return `/sap/bc/adt/oo/interfaces/${enc(n)}`;
+    case "FUGR":
+      return `/sap/bc/adt/functions/groups/${enc(n)}`;
+    case "FUGR/FF": {
+      if (!group) {
+        throw new Error(
+          `Function module '${name}': pass 'group' (the function group name)`
+        );
+      }
+      return `/sap/bc/adt/functions/groups/${enc(group.toLowerCase())}/fmodules/${enc(n)}`;
+    }
+    case "FUGR/I": {
+      if (!group) {
+        throw new Error(
+          `Function group include '${name}': pass 'group' (the function group name)`
+        );
+      }
+      return `/sap/bc/adt/functions/groups/${enc(group.toLowerCase())}/includes/${enc(n)}`;
+    }
+    case "TABL":
+      return `/sap/bc/adt/ddic/tables/${enc(n)}`;
+    case "DTEL":
+      return `/sap/bc/adt/ddic/dataelements/${enc(n)}`;
+    case "DOMA":
+      return `/sap/bc/adt/ddic/domains/${enc(n)}`;
+    case "DDLS":
+      return `/sap/bc/adt/ddic/ddl/sources/${enc(n)}`;
+    case "DCLS":
+      return `/sap/bc/adt/acm/dcls/${enc(n)}`;
+    case "DDLX":
+      return `/sap/bc/adt/ddic/ddlx/sources/${enc(n)}`;
+    case "BDEF":
+      return `/sap/bc/adt/bo/behaviordefinitions/${enc(n)}`;
+    case "SRVD":
+      return `/sap/bc/adt/ddic/srvd/sources/${enc(n)}`;
+    case "SRVB":
+      return `/sap/bc/adt/businessservices/bindings/${enc(n)}`;
+    case "MSAG":
+      return `/sap/bc/adt/messageclasses/${enc(n)}`;
+    default:
+      throw new Error(`Unsupported object type: ${type} (normalized: ${t})`);
+  }
+}
+
+export function sourceUri({ type, name, group, include }) {
+  const t = normalizeType(type);
+  const base = objectUri({ type: t, name, group });
+
+  if (t === "CLAS") {
+    const inc = include ? CLASS_INCLUDES[include.toLowerCase()] : "main";
+    if (!inc) {
+      throw new Error(
+        `Unknown class include '${include}'. Use one of: ${Object.keys(CLASS_INCLUDES).join(", ")}`
+      );
+    }
+    return inc === "main"
+      ? `${base}/source/main`
+      : `${base}/includes/${inc}`;
+  }
+
+  // DDIC primitives have no separate source endpoint in the form X/source/main.
+  // Tables, data elements, domains and message classes expose object metadata
+  // via the object URI directly, returned as XML. CDS / DCLS / DDLX / BDEF do
+  // use /source/main.
+  if (t === "DTEL" || t === "DOMA" || t === "MSAG") return base;
+  if (t === "TABL") return `${base}/source/main`;
+
+  return `${base}/source/main`;
+}
+
+function enc(s) {
+  return encodeURIComponent(s);
+}