@cspeach/cli 1.1.18 → 1.1.19

package/dist/tools/verify.js

@@ -10,20 +10,177 @@
  *
  * (Confirmed from sap-client/src/adt-client.ts lines 82-87, 224-228, 547.)
  */
+import { recordSyntaxCheck } from './syntax-state.js';
+import { toObjectUrl, xmlParser } from '@cspeach/sap-client';
+/** Line for display: the parsed line, else the `#start=L,C` fragment of the
+ *  checkruns uri (sap-client <= 0.1.14 left line at 0 for checkruns). */
+function lineOf(m) {
+    if (m.line > 0)
+        return m.line;
+    const pos = m.uri ? /#(?:.*[;&])?start=(\d+)/.exec(m.uri) : null;
+    return pos ? parseInt(pos[1], 10) : m.line;
+}
+function columnOf(m) {
+    if ((m.column ?? 0) > 0 || m.line > 0)
+        return m.column ?? 0;
+    const pos = m.uri ? /#(?:.*[;&])?start=\d+,(\d+)/.exec(m.uri) : null;
+    return pos ? parseInt(pos[1], 10) : (m.column ?? 0);
+}
+/** sap-client <= 0.1.14 passed `chkrun:shortText` through still XML-escaped. */
+function decodeEntities(s) {
+    return s.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+}
+/**
+ * Normalise a sap-client syntax-check result. FAILS CLOSED — every consumer
+ * of a syntax check (the Rule 10 write gate, the sap_syntax_check tool the
+ * model reads, the doctor probe) goes through here (fix round 7, item 1).
+ *
+ *  - `hasErrors` from sap-client always stands.
+ *  - A message with a severity other than warning/info is an error.
+ *  - sap-client <= 0.1.14 read checkruns severities from the wrong attribute
+ *    (every `chkrun:type="E"` came back as `info`, text still XML-escaped,
+ *    line 0) and always added one empty, uri-less message for the
+ *    `<checkMessageList>` container. That empty message is the fingerprint of
+ *    a result whose severities were lost: then every remaining non-warning
+ *    message is treated as an error, so a broken program never passes as
+ *    clean on the old pin. The empty artefact itself is dropped.
+ */
+export function normaliseSyntaxResult(res) {
+    const all = (res.messages ?? []);
+    const severitiesLost = all.some((m) => !m.text && !m.uri);
+    const messages = all
+        .filter((m) => m.text || m.uri)
+        .map((m) => {
+        const severity = m.severity === 'warning' ? 'warning'
+            : m.severity === 'info' && !severitiesLost ? 'info'
+                : 'error';
+        return {
+            severity,
+            line: lineOf(m),
+            column: columnOf(m),
+            text: decodeEntities(m.text ?? ''),
+            ...(m.uri !== undefined ? { uri: m.uri } : {}),
+        };
+    });
+    if (res.hasErrors && !messages.some((m) => m.severity === 'error')) {
+        messages.unshift({ severity: 'error', line: 0, column: 0, text: 'SAP reported syntax errors (no message text returned)' });
+    }
+    return {
+        hasErrors: messages.some((m) => m.severity === 'error'),
+        hasWarnings: messages.some((m) => m.severity === 'warning'),
+        messages,
+    };
+}
+/**
+ * Final review A-I2 — the ONE syntax-check call every CLI consumer uses.
+ *
+ * Live S4H capture (test/fixtures/checkruns-s4h): for BDEF, DDLX, SRVD and
+ * TABL, sap-client 0.1.15's request (no version) is answered
+ * `chkrun:status="notProcessed"` ("Error while importing object … from the
+ * database") when the object has NO inactive version — e.g. right after the
+ * write was activated — and 0.1.15 throws "did not run". The same request
+ * with `chkrun:version="active"` is processed.
+ *
+ * So: on a notProcessed throw, and ONLY when the object is confirmed NOT in
+ * the inactive-objects list (then the active version is the current source),
+ * check once more with version="active" and require a processed report.
+ * Anything else — an inactive version exists, the list is unreadable, the
+ * retry is not processed — rethrows the original error (fail closed).
+ */
+export async function checkSyntax(adt, type, name) {
+    try {
+        return await adt.syntaxCheck(type, name);
+    }
+    catch (err) {
+        if (!/did not run \(status notProcessed\)/i.test(String(err?.message ?? err)))
+            throw err;
+        const retried = await checkActiveVersion(adt, type, name).catch(() => undefined);
+        if (retried)
+            return retried;
+        throw err;
+    }
+}
+const connOf = (adt) => adt.connection;
+const INACTIVE_URL = '/sap/bc/adt/activation/inactiveobjects';
+/**
+ * Re-review of the final fix wave, item 2 — the published 0.1.15
+ * inactive-list parser returns [] when the object's name sits on a CHILD
+ * <ioc:ref> element (test/fixtures/inactive-objects), so "[] = no inactive
+ * version" cannot be trusted. Read the RAW body: does it mention this object
+ * (name, or its ADT uri, as a whole word)?
+ */
+export function inactiveBodyMentions(body, type, name) {
+    const esc = (v) => v.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const upper = name.toUpperCase();
+    const byName = new RegExp(`(?<![A-Z0-9_/])${esc(upper)}(?![A-Z0-9_])`).test(body.toUpperCase());
+    let byUri = false;
+    try {
+        const uri = toObjectUrl(type, upper).toLowerCase();
+        byUri = new RegExp(`${esc(uri)}(?![a-z0-9_])`).test(body.toLowerCase());
+    }
+    catch { /* unknown type word: the name check stands */ }
+    return byName || byUri;
+}
+async function checkActiveVersion(adt, type, name) {
+    const upper = name.toUpperCase();
+    const conn = connOf(adt);
+    if (!conn || typeof conn.post !== 'function' || typeof conn.get !== 'function')
+        return undefined;
+    // Parser-independent guard: never check the old active source while an
+    // inactive version may exist.
+    const list = await conn.get(INACTIVE_URL);
+    if (list.status < 200 || list.status >= 300)
+        return undefined;
+    const body = list.body ?? '';
+    if (inactiveBodyMentions(body, type, upper))
+        return undefined;
+    const inactive = await adt.inactiveObjects();
+    if (inactive.some((o) => o.name.toUpperCase() === upper))
+        return undefined;
+    // Controller ruling: no "body has refs but parses to nothing" rule — with the
+    // 0.1.15 parser bug it refused the retry whenever the user had ANY other
+    // inactive object, re-blocking every clean BDEF/DDLX/SRVD/TABL write. The
+    // whole-word raw-body check above (plus non-2xx → refuse) is the guard.
+    const esc = (v) => v.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');
+    const xml = '<?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">'
+        + `<chkrun:checkObject adtcore:uri="${esc(toObjectUrl(type, upper))}" chkrun:version="active"/>`
+        + '</chkrun:checkObjectList>';
+    const resp = await conn.post('/sap/bc/adt/checkruns?reporters=abapCheckRun', xml, 'application/vnd.sap.adt.checkobjects+xml; charset=utf-8', 'application/xml, */*');
+    if (resp.status < 200 || resp.status >= 300)
+        return undefined;
+    const report = /<(?:[\w-]+:)?checkReport(?![\w-])([^>]*)>/i.exec(resp.body ?? '');
+    const status = report ? /(?:^|\s)(?:[\w-]+:)?status\s*=\s*"([^"]*)"/.exec(report[1] ?? '')?.[1] : undefined;
+    if (!report || (status !== undefined && status.toLowerCase() !== 'processed'))
+        return undefined;
+    return xmlParser.parseSyntaxCheckResult(resp.body);
+}
 /**
  * Run a syntax check and return a normalised VerifyResult.
  * Errors block activation; warnings are surfaced but do not block.
+ * Fails closed — see normaliseSyntaxResult.
  */
 export async function verifySyntax(adt, name, type) {
-    const res = await adt.syntaxCheck(type, name);
+    // Review r7 I-4 — a check that did not run (HTTP error, aborted report,
+    // network) FAILS CLOSED: never syntax ✓, never activation_allowed.
+    let raw;
+    let didNotRun;
+    try {
+        raw = await checkSyntax(adt, type, name);
+    }
+    catch (err) {
+        didNotRun = String(err?.message ?? err).replace(/\s+/g, ' ').trim();
+        raw = { hasErrors: true, hasWarnings: false, messages: [{ severity: 'error', line: 0, column: 0,
+                    text: /did not run/i.test(didNotRun) ? didNotRun : `Syntax check did not run: ${didNotRun}` }] };
+    }
+    const res = normaliseSyntaxResult(raw);
+    recordSyntaxCheck(type, name, res.hasErrors); // round 7 item 8e
+    const fmt = (m) => (m.line > 0 || m.uri ? `L${m.line}: ${m.text}` : m.text);
     return {
         ok: !res.hasErrors,
-        errors: res.messages
-            .filter((m) => m.severity === 'error')
-            .map((m) => `L${m.line}: ${m.text}`),
-        warnings: res.messages
-            .filter((m) => m.severity === 'warning')
-            .map((m) => `L${m.line}: ${m.text}`),
+        errors: res.messages.filter((m) => m.severity === 'error').map(fmt),
+        warnings: res.messages.filter((m) => m.severity === 'warning').map(fmt),
+        ...(didNotRun !== undefined ? { didNotRun } : {}),
     };
 }
 export async function verifyActive(adt, name, type) {
@@ -34,6 +191,25 @@ export async function verifyActive(adt, name, type) {
     catch (err) {
         return { active: false, verifyError: String(err?.message ?? err) };
     }
-    const stillInactive = inactive.some((o) => o.name.toUpperCase() === name.toUpperCase() && o.type.toUpperCase() === type.toUpperCase());
+    // Re-review of the final fix wave, item 1 — the list carries ADT codes with
+    // a slash (PROG/P, CLAS/OC, DDLS/DF), so an exact type compare never matched
+    // and still-inactive objects read as active. Match by object NAME: a
+    // same-named object of another type only errs on the safe side.
+    let stillInactive = inactive.some((o) => o.name.toUpperCase() === name.toUpperCase());
+    // Re-review item 2 — parser-independent: the raw body mentioning the object
+    // also means still inactive (0.1.15 misses names on a child <ioc:ref>).
+    const conn = connOf(adt);
+    if (!stillInactive && conn && typeof conn.get === 'function') {
+        try {
+            const list = await conn.get(INACTIVE_URL);
+            if (list.status >= 200 && list.status < 300)
+                stillInactive = inactiveBodyMentions(list.body ?? '', type, name);
+            else
+                return { active: false, verifyError: `inactive-objects list answered HTTP ${list.status}` };
+        }
+        catch (err) {
+            return { active: false, verifyError: String(err?.message ?? err) };
+        }
+    }
     return { active: !stillInactive };
 }