abap-local-client 1.0.0

package/sap-rfc-client.js

@@ -0,0 +1,852 @@
+/**
+ * SAP RFC Client — ADT over SAProuter
+ *
+ * Uses koffi + sapnwrfc.dll to call the ABAP function module
+ * SADT_REST_RFC_ENDPOINT, which tunnels HTTP requests over RFC.
+ *
+ * Protocol (discovered by capturing Eclipse traffic):
+ *  1. Eclipse connects to SAP Gateway port 3300 via SAProuter (NI_ROUTE)
+ *  2. RFC SDK handles NI handshake automatically
+ *  3. Eclipse calls SADT_REST_RFC_ENDPOINT with method/URI/headers/body
+ *  4. SAP executes the HTTP request internally and returns the HTTP response
+ *
+ * Config object:
+ *   host      – SAP application server hostname (e.g. vhvcddevci.sap.vissimo.com.br)
+ *   sysnr     – System number (e.g. '00')
+ *   client    – SAP client (e.g. '100')
+ *   username  – SAP logon user
+ *   password  – SAP logon password
+ *   language  – Logon language (default 'EN')
+ *   saprouter – SAProuter string (e.g. '/H/52.202.238.115')
+ */
+
+import koffi from 'koffi';
+
+// ============================================================================
+// Load sapnwrfc.dll (must be in PATH, usually C:\Windows\System32)
+// ============================================================================
+
+let lib;
+try {
+    lib = koffi.load('sapnwrfc.dll');
+} catch (err) {
+    throw new Error(
+        `Cannot load sapnwrfc.dll: ${err.message}\n` +
+        'Make sure SAP NW RFC SDK is installed and sapnwrfc.dll is in C:\\Windows\\System32.'
+    );
+}
+
+// ============================================================================
+// koffi Type Definitions
+// ============================================================================
+
+// RFC_ERROR_INFO — must exactly match sapnwrfc.h RFC_ERROR_INFO struct
+const RFC_ERROR_INFO = koffi.struct('RFC_ERROR_INFO', {
+    code:         'int32',
+    group:        'int32',
+    key:          koffi.array('uint16', 128),
+    message:      koffi.array('uint16', 512),
+    abapMsgClass: koffi.array('uint16', 20),
+    abapMsgType:  koffi.array('uint16', 1),
+    abapMsgNumber:koffi.array('uint16', 3),
+    abapMsgV1:    koffi.array('uint16', 50),
+    abapMsgV2:    koffi.array('uint16', 50),
+    abapMsgV3:    koffi.array('uint16', 50),
+    abapMsgV4:    koffi.array('uint16', 50),
+});
+
+// RFC_CONNECTION_PARAMETER — name/value pair (SAP_UC*)
+const RFC_CONNECTION_PARAMETER = koffi.struct('RFC_CONNECTION_PARAMETER', {
+    name:  koffi.pointer('uint16'),
+    value: koffi.pointer('uint16'),
+});
+
+// RFC_PARAMETER_DESC — describes one parameter of a function module.
+// Layout taken from sapnwrfc.h.
+const RFC_PARAMETER_DESC = koffi.struct('RFC_PARAMETER_DESC', {
+    name:                koffi.array('uint16', 31),  // 30 chars + NUL
+    type:                'int32',                     // RFCTYPE
+    direction:           'int32',                     // RFC_DIRECTION
+    nucLength:           'uint32',
+    ucLength:            'uint32',
+    decimals:            'uint32',
+    typeDescHandle:      'void *',
+    defaultValue:        koffi.array('uint16', 31),   // SAP_UC[31]
+    parameterText:       koffi.array('uint16', 80),
+    optional:            'uint8',
+    extendedDescription: 'void *',
+});
+
+const RFC_DIRECTION_NAMES = {
+    1: 'IMPORT',
+    2: 'EXPORT',
+    3: 'CHANGING',
+    7: 'TABLES',
+};
+
+const RFC_TYPE_NAMES = {
+    0:  'CHAR',     1:  'DATE',    2:  'BCD',     3:  'TIME',
+    4:  'BYTE',     5:  'TABLE',   6:  'NUM',     7:  'FLOAT',
+    8:  'INT',      9:  'INT2',    10: 'INT1',    14: 'NULL',
+    16: 'ABAPOBJ',  17: 'STRUCT',  23: 'DECF16',  24: 'DECF34',
+    28: 'XMLDATA',  29: 'STRING',  30: 'XSTRING', 31: 'INT8',
+    32: 'UTCLONG',
+};
+
+// ============================================================================
+// RFC SDK Function Bindings
+// ============================================================================
+
+const RfcOpenConnection = lib.func('RfcOpenConnection', 'void *', [
+    koffi.pointer(RFC_CONNECTION_PARAMETER),
+    'uint32',
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+const RfcCloseConnection = lib.func('RfcCloseConnection', 'int32', [
+    'void *',
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+const RfcGetFunctionDesc = lib.func('RfcGetFunctionDesc', 'void *', [
+    'void *',
+    koffi.pointer('uint16'),
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+const RfcCreateFunction = lib.func('RfcCreateFunction', 'void *', [
+    'void *',
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+const RfcDestroyFunction = lib.func('RfcDestroyFunction', 'int32', [
+    'void *',
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+const RfcInvoke = lib.func('RfcInvoke', 'int32', [
+    'void *',
+    'void *',
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+// DATA_CONTAINER_HANDLE is used for both function handles and structure handles
+const RfcGetStructure = lib.func('RfcGetStructure', 'int32', [
+    'void *',                              // data container
+    koffi.pointer('uint16'),               // field name (SAP_UC*)
+    koffi.out(koffi.pointer('void *')),    // output: RFC_STRUCTURE_HANDLE*
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+const RfcGetTable = lib.func('RfcGetTable', 'int32', [
+    'void *',
+    koffi.pointer('uint16'),
+    koffi.out(koffi.pointer('void *')),    // output: RFC_TABLE_HANDLE*
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+const RfcAppendNewRow = lib.func('RfcAppendNewRow', 'void *', [
+    'void *',
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+// RfcGetRowCount — API is:
+//   RFC_RC RfcGetRowCount(RFC_TABLE_HANDLE tableHandle,
+//                         unsigned *rowCount,
+//                         RFC_ERROR_INFO *errorInfo);
+// Returns RFC_RC; row count is written to the out-pointer.
+const RfcGetRowCount = lib.func('RfcGetRowCount', 'int32', [
+    'void *',
+    koffi.out(koffi.pointer('uint32')),
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+const RfcMoveToFirstRow = lib.func('RfcMoveToFirstRow', 'int32', [
+    'void *',
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+const RfcMoveToNextRow = lib.func('RfcMoveToNextRow', 'int32', [
+    'void *',
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+const RfcGetCurrentRow = lib.func('RfcGetCurrentRow', 'void *', [
+    'void *',
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+// RfcSetString — write a string value into a field (SAP_UC* value)
+const RfcSetString = lib.func('RfcSetString', 'int32', [
+    'void *',
+    koffi.pointer('uint16'),   // field name
+    koffi.pointer('uint16'),   // value (SAP_UC*)
+    'uint32',                  // value length in chars (NOT bytes)
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+// RfcSetXString — write binary data into a XSTRING field
+const RfcSetXString = lib.func('RfcSetXString', 'int32', [
+    'void *',
+    koffi.pointer('uint16'),   // field name
+    koffi.pointer('uint8'),    // byte buffer (SAP_RAW*)
+    'uint32',                  // byte length
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+// RfcGetStringLength — get the char length of a string field
+const RfcGetStringLength = lib.func('RfcGetStringLength', 'int32', [
+    'void *',
+    koffi.pointer('uint16'),
+    koffi.out(koffi.pointer('uint32')),
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+// RfcGetString — read a string field into a caller-provided SAP_UC buffer
+const RfcGetString = lib.func('RfcGetString', 'int32', [
+    'void *',
+    koffi.pointer('uint16'),   // field name
+    koffi.pointer('uint16'),   // output buffer (SAP_UC*)  ← C writes here
+    'uint32',                  // buffer capacity in chars
+    koffi.out(koffi.pointer('uint32')),  // actual length written
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+// RfcGetXString — read a XSTRING field into a caller-provided byte buffer
+// Pass bufferLength=0 first to get the required length (returns RFC_BUFFER_TOO_SMALL=1)
+const RfcGetXString = lib.func('RfcGetXString', 'int32', [
+    'void *',
+    koffi.pointer('uint16'),   // field name
+    koffi.pointer('uint8'),    // output byte buffer  ← C writes here
+    'uint32',                  // buffer capacity in bytes
+    koffi.out(koffi.pointer('uint32')),  // actual byte length
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+// RfcGetChars — read a CHAR field (fixed-length) into a caller-provided SAP_UC buffer
+// Used for fields like ABAPTXT255.LINE (CHAR255) where RfcGetString does not work.
+const RfcGetChars = lib.func('RfcGetChars', 'int32', [
+    'void *',
+    koffi.pointer('uint16'),   // field name
+    koffi.pointer('uint16'),   // output buffer (SAP_UC*)
+    'uint32',                  // buffer capacity in chars
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+// Metadata introspection — list parameters of a function module
+const RfcGetParameterCount = lib.func('RfcGetParameterCount', 'int32', [
+    'void *',                                    // RFC_FUNCTION_DESC_HANDLE
+    koffi.out(koffi.pointer('uint32')),
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+const RfcGetParameterDescByIndex = lib.func('RfcGetParameterDescByIndex', 'int32', [
+    'void *',                                    // RFC_FUNCTION_DESC_HANDLE
+    'uint32',                                    // index
+    koffi.out(koffi.pointer(RFC_PARAMETER_DESC)),
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+// RFC_FIELD_DESC — describes one field inside a structure/table row.
+// Layout from sapnwrfc.h.
+const RFC_FIELD_DESC = koffi.struct('RFC_FIELD_DESC', {
+    name:           koffi.array('uint16', 31),
+    type:           'int32',
+    nucLength:      'uint32',
+    ucLength:       'uint32',
+    nucOffset:      'uint32',
+    ucOffset:       'uint32',
+    decimals:       'uint32',
+    typeDescHandle: 'void *',
+    extendedDescription: 'void *',
+});
+
+// Introspect fields of a type (structure / table row).
+const RfcGetFieldCount = lib.func('RfcGetFieldCount', 'int32', [
+    'void *',                               // RFC_TYPE_DESC_HANDLE
+    koffi.out(koffi.pointer('uint32')),
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+const RfcGetFieldDescByIndex = lib.func('RfcGetFieldDescByIndex', 'int32', [
+    'void *',                               // RFC_TYPE_DESC_HANDLE
+    'uint32',                               // index
+    koffi.out(koffi.pointer(RFC_FIELD_DESC)),
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+// Retrieve the type description handle for a table parameter.
+const RfcDescribeType = lib.func('RfcDescribeType', 'void *', [
+    'void *',                               // data container (table handle or struct handle)
+    koffi.out(koffi.pointer(RFC_ERROR_INFO)),
+]);
+
+// ============================================================================
+// Helper Utilities
+// ============================================================================
+
+/** Convert a JS string to a SAP_UC (UTF-16LE) null-terminated Buffer */
+function sapStr(s) {
+    const buf = Buffer.alloc((s.length + 1) * 2, 0);
+    buf.write(s, 0, 'utf16le');
+    return buf;
+}
+
+/** Decode a uint16[] array (from RFC_ERROR_INFO) to a JS string */
+function decodeU16Array(arr) {
+    const end = arr.findIndex(c => c === 0);
+    const slice = end >= 0 ? arr.slice(0, end) : arr;
+    return Buffer.from(new Uint16Array(slice).buffer).toString('utf16le');
+}
+
+/** Create a blank RFC_ERROR_INFO JS object */
+function newErr() {
+    return {
+        code: 0, group: 0,
+        key:          new Array(128).fill(0),
+        message:      new Array(512).fill(0),
+        abapMsgClass: new Array(20).fill(0),
+        abapMsgType:  new Array(1).fill(0),
+        abapMsgNumber:new Array(3).fill(0),
+        abapMsgV1:    new Array(50).fill(0),
+        abapMsgV2:    new Array(50).fill(0),
+        abapMsgV3:    new Array(50).fill(0),
+        abapMsgV4:    new Array(50).fill(0),
+    };
+}
+
+/**
+ * Read a STRING field value from a data container.
+ * Returns '' on any error.
+ */
+function readStringField(container, fieldName) {
+    const lenPtr = [0];
+    const e = newErr();
+    const rc = RfcGetStringLength(container, sapStr(fieldName), lenPtr, e);
+    if (rc !== 0 || lenPtr[0] === 0) { return ''; }
+    const buf = Buffer.alloc((lenPtr[0] + 1) * 2, 0);
+    const actualLen = [0];
+    RfcGetString(container, sapStr(fieldName), buf, lenPtr[0] + 1, actualLen, e);
+    return buf.slice(0, actualLen[0] * 2).toString('utf16le');
+}
+
+/**
+ * Read ALL fields of a row container and return them pipe-separated.
+ * Uses RfcDescribeType → RfcGetTypeFieldCount → RfcGetFieldDescByIndex to
+ * discover the field names at runtime, then reads each via STRING or CHAR.
+ *
+ * Falls back to readStringField('LINE') when type introspection fails
+ * (e.g. flat-char structures without a proper type handle).
+ *
+ * @param {*}  row          - RFC row handle (from RfcGetCurrentRow)
+ * @param {string[]} [hint] - optional ordered field-name list; when provided
+ *                            the type-introspection step is skipped.
+ * @returns {string}  pipe-separated field values, trailing spaces stripped.
+ */
+function readAllFields(row, hint) {
+    const e = newErr();
+
+    // Fast path: caller already knows the field names.
+    if (hint && hint.length > 0) {
+        return hint.map(f => {
+            const sv = readStringField(row, f);
+            if (sv !== '') { return sv.trimEnd(); }
+            return readCharField(row, f).trimEnd();
+        }).join('|');
+    }
+
+    // Introspect the type associated with this row.
+    const typeHandle = RfcDescribeType(row, e);
+    if (!typeHandle) {
+        // Flat-char fallback: try LINE (ABAPTXT255, ABAPSOURCE, etc.)
+        const line = readStringField(row, 'LINE');
+        if (line !== '') { return line.trimEnd(); }
+        return readCharField(row, 'LINE').trimEnd();
+    }
+
+    const countPtr = [0];
+    const rcCount = RfcGetFieldCount(typeHandle, countPtr, e);
+    if (rcCount !== 0 || countPtr[0] === 0) {
+        return readCharField(row, 'LINE').trimEnd();
+    }
+
+    const parts = [];
+    for (let i = 0; i < countPtr[0]; i++) {
+        const fd = {
+            name: new Array(31).fill(0),
+            type: 0, nucLength: 0, ucLength: 0,
+            nucOffset: 0, ucOffset: 0, decimals: 0,
+            typeDescHandle: null, extendedDescription: null,
+        };
+        if (RfcGetFieldDescByIndex(typeHandle, i, fd, e) !== 0) { continue; }
+        const fname = decodeU16Array(fd.name);
+        if (!fname) { continue; }
+        const sv = readStringField(row, fname);
+        if (sv !== '') { parts.push(sv.trimEnd()); continue; }
+        parts.push(readCharField(row, fname).trimEnd());
+    }
+    return parts.join('|');
+}
+
+/**
+ * Read a CHAR field (fixed-length, like ABAPTXT255.LINE = CHAR255).
+ * Allocates a fixed buffer; default 4096 chars covers ABAPSOURCE/ABAPTXT*.
+ * Returns the value with trailing NULLs and spaces stripped.
+ * Returns '' if the field is not CHAR or read fails.
+ */
+function readCharField(container, fieldName, maxChars = 4096) {
+    const e = newErr();
+    const buf = Buffer.alloc(maxChars * 2, 0);
+    const rc = RfcGetChars(container, sapStr(fieldName), buf, maxChars, e);
+    if (rc !== 0) { return ''; }
+    return buf.toString('utf16le').replace(/[\u0000\s]+$/, '');
+}
+
+/**
+ * Read an XSTRING field.  Two-pass: first call discovers the required buffer
+ * size (RFC returns RFC_BUFFER_TOO_SMALL=1), second call retrieves the data.
+ * Returns a Buffer (possibly empty).
+ */
+function readXStringField(container, fieldName) {
+    const e = newErr();
+    const lenPtr = [0];
+    const dummy = Buffer.alloc(1, 0);
+    // First pass — get size
+    RfcGetXString(container, sapStr(fieldName), dummy, 0, lenPtr, e);
+    if (lenPtr[0] === 0) { return Buffer.alloc(0); }
+    const buf = Buffer.alloc(lenPtr[0], 0);
+    const actualLen = [0];
+    RfcGetXString(container, sapStr(fieldName), buf, lenPtr[0], actualLen, e);
+    return buf.slice(0, actualLen[0]);
+}
+
+// ============================================================================
+// Build RFC Connection Parameters
+// ============================================================================
+
+function buildConnParams(config) {
+    const pairs = [
+        ['ASHOST',    config.host],
+        ['SYSNR',     config.sysnr     || '00'],
+        ['CLIENT',    config.client    || '100'],
+        ['USER',      config.username],
+        ['PASSWD',    config.password],
+        ['LANG',      config.language  || 'EN'],
+    ];
+    if (config.saprouter) {
+        pairs.push(['SAPROUTER', config.saprouter]);
+    }
+    // SNC parameters (Secure Network Communication)
+    if (config.sncMode)        pairs.push(['SNC_MODE',   config.sncMode]);
+    if (config.sncMyName)      pairs.push(['SNC_MYNAME', config.sncMyName]);
+    if (config.sncPartnerName) pairs.push(['SNC_PARTNERNAME', config.sncPartnerName]);
+    if (config.sncQop)         pairs.push(['SNC_QOP',    config.sncQop]);
+    if (config.sncLib)         pairs.push(['SNC_LIB',    config.sncLib]);
+    // Keep buffers alive to prevent GC during the call
+    const bufs = pairs.map(([n, v]) => ({ nameBuf: sapStr(n), valueBuf: sapStr(v || '') }));
+    return bufs.map(b => ({ name: b.nameBuf, value: b.valueBuf }));
+}
+
+// ============================================================================
+// SAP RFC Client Class
+// ============================================================================
+
+export class SAPRFCClient {
+    constructor(config) {
+        this.config = config;
+        this.conn = null;
+        this.csrfToken = null;
+        const sncInfo = config.sncMode ? ` SNC=yes (${config.sncMyName || 'auto'})` : '';
+        console.log(`[RFC] SAP RFC client configured — host=${config.host} sysnr=${config.sysnr || '00'} saprouter=${config.saprouter || 'none'}${sncInfo}`);
+    }
+
+    /** Open RFC connection (keep-alive between calls) */
+    async connect() {
+        if (this.conn) { return; }
+        console.log('[RFC] Opening RFC connection...');
+        const params = buildConnParams(this.config);
+        const errInfo = newErr();
+        this.conn = RfcOpenConnection(params, params.length, errInfo);
+        if (!this.conn) {
+            const msg = decodeU16Array(errInfo.message);
+            throw new Error(`RFC connection failed (code=${errInfo.code}): ${msg}`);
+        }
+        console.log('[RFC] RFC connection established ✅');
+    }
+
+    /**
+     * List all parameters of a function module as the RFC SDK sees them.
+     * Returns an array of { name, direction, type, length } objects and
+     * also prints them to the console (handy for diagnostics).
+     */
+    async inspectFM(fmName) {
+        await this.connect();
+        const e = newErr();
+        const funcDesc = RfcGetFunctionDesc(this.conn, sapStr(fmName), e);
+        if (!funcDesc) {
+            throw new Error(`RfcGetFunctionDesc(${fmName}) failed (code=${e.code}): ${decodeU16Array(e.message)}`);
+        }
+        const countPtr = [0];
+        const rcCount = RfcGetParameterCount(funcDesc, countPtr, e);
+        if (rcCount !== 0) {
+            throw new Error(`RfcGetParameterCount(${fmName}) failed (code=${e.code}): ${decodeU16Array(e.message)}`);
+        }
+        const total = countPtr[0];
+        console.log(`[RFC] ${fmName} has ${total} parameter(s) according to SAP metadata:`);
+        const params = [];
+        for (let i = 0; i < total; i++) {
+            const desc = {
+                name: new Array(31).fill(0),
+                type: 0, direction: 0, nucLength: 0, ucLength: 0, decimals: 0,
+                typeDescHandle: null,
+                defaultValue: new Array(31).fill(0),
+                parameterText: new Array(80).fill(0),
+                optional: 0,
+                extendedDescription: null,
+            };
+            const rc = RfcGetParameterDescByIndex(funcDesc, i, desc, e);
+            if (rc !== 0) {
+                console.log(`  [${i}] (read failed: ${decodeU16Array(e.message)})`);
+                continue;
+            }
+            const name = decodeU16Array(desc.name);
+            const dir  = RFC_DIRECTION_NAMES[desc.direction] || `dir=${desc.direction}`;
+            const type = RFC_TYPE_NAMES[desc.type] || `type=${desc.type}`;
+            console.log(`  [${i}] ${dir.padEnd(8)} ${name.padEnd(30)} ${type} (${desc.ucLength / 2} chars)`);
+            params.push({ name, direction: dir, type, length: desc.ucLength / 2 });
+        }
+        return params;
+    }
+
+    /** Close the persistent RFC connection */
+    disconnect() {
+        if (this.conn) {
+            RfcCloseConnection(this.conn, newErr());
+            this.conn = null;
+            console.log('[RFC] RFC connection closed');
+        }
+    }
+
+    /**
+     * Call SADT_REST_RFC_ENDPOINT to tunnel an ADT HTTP request.
+     *
+     * @param {string} method   – HTTP method (GET, POST, PUT, DELETE)
+     * @param {string} uri      – Relative path + query string (/sap/bc/adt/...)
+     * @param {Object} headers  – HTTP headers as key→value
+     * @param {string|Buffer} body – Request body (may be empty)
+     * @returns {Object} { status, statusText, headers, data }
+     */
+    async callADT(method, uri, headers, body) {
+        await this.connect();
+
+        const e = newErr();
+
+        // ── Get function description (cached by RFC SDK after first call) ──
+        const funcDesc = RfcGetFunctionDesc(this.conn, sapStr('SADT_REST_RFC_ENDPOINT'), e);
+        if (!funcDesc) {
+            throw new Error(`RfcGetFunctionDesc failed (code=${e.code}): ${decodeU16Array(e.message)}`);
+        }
+
+        // ── Create function call container ──
+        const func = RfcCreateFunction(funcDesc, e);
+        if (!func) {
+            throw new Error(`RfcCreateFunction failed: ${decodeU16Array(e.message)}`);
+        }
+
+        try {
+            // ── Set REQUEST parameter (deep structure) ──
+            //    Structure: REQUEST_LINE (struct), HEADER_FIELDS (table), MESSAGE_BODY (XSTRING)
+            const requestRef = [null];
+            RfcGetStructure(func, sapStr('REQUEST'), requestRef, e);
+            const request = requestRef[0];
+
+            if (request) {
+                // REQUEST_LINE sub-structure
+                const reqLineRef = [null];
+                RfcGetStructure(request, sapStr('REQUEST_LINE'), reqLineRef, e);
+                const reqLine = reqLineRef[0];
+                if (reqLine) {
+                    RfcSetString(reqLine, sapStr('METHOD'),  sapStr(method),     method.length,    e);
+                    RfcSetString(reqLine, sapStr('URI'),     sapStr(uri),        uri.length,       e);
+                    RfcSetString(reqLine, sapStr('VERSION'), sapStr('HTTP/1.1'), 'HTTP/1.1'.length, e);
+                }
+
+                // HEADER_FIELDS table
+                const headerTableRef = [null];
+                RfcGetTable(request, sapStr('HEADER_FIELDS'), headerTableRef, e);
+                const headerTable = headerTableRef[0];
+                if (headerTable) {
+                    for (const [name, value] of Object.entries(headers || {})) {
+                        const row = RfcAppendNewRow(headerTable, e);
+                        if (row) {
+                            const v = String(value);
+                            RfcSetString(row, sapStr('NAME'),  sapStr(name), name.length, e);
+                            RfcSetString(row, sapStr('VALUE'), sapStr(v),    v.length,    e);
+                        }
+                    }
+                }
+
+                // MESSAGE_BODY (XSTRING)
+                if (body && body.length > 0) {
+                    const bodyBuf = Buffer.isBuffer(body) ? body : Buffer.from(body, 'utf8');
+                    RfcSetXString(request, sapStr('MESSAGE_BODY'), bodyBuf, bodyBuf.length, e);
+                }
+            } else {
+                // Fallback: flat parameter layout (no REQUEST wrapper)
+                this._setFlatParams(func, method, uri, headers, body, e);
+            }
+
+            // ── Invoke the function module ──
+            const invokeErr = newErr();
+            const rc = RfcInvoke(this.conn, func, invokeErr);
+            if (rc !== 0) {
+                const msg = decodeU16Array(invokeErr.message);
+                // If connection is broken, reset it so next call reconnects
+                if (invokeErr.code === 1 || invokeErr.code === 3) { // RFC_COMMUNICATION_FAILURE or RFC_ABAP_EXCEPTION
+                    this.conn = null;
+                }
+                throw new Error(`SADT_REST_RFC_ENDPOINT failed (rc=${rc} code=${invokeErr.code}): ${msg}`);
+            }
+
+            // ── Read RESPONSE parameter ──
+            const responseRef = [null];
+            RfcGetStructure(func, sapStr('RESPONSE'), responseRef, e);
+            const response = responseRef[0];
+
+            let statusCode = 200;
+            let statusText = 'OK';
+            const responseHeaders = {};
+            let responseBody = Buffer.alloc(0);
+
+            if (response) {
+                // STATUS_LINE
+                const statusLineRef = [null];
+                RfcGetStructure(response, sapStr('STATUS_LINE'), statusLineRef, e);
+                const statusLine = statusLineRef[0];
+                if (statusLine) {
+                    const code = readStringField(statusLine, 'STATUS_CODE');
+                    const phrase = readStringField(statusLine, 'REASON_PHRASE');
+                    if (code) { statusCode = parseInt(code) || 200; }
+                    if (phrase) { statusText = phrase; }
+                }
+
+                // HEADER_FIELDS table
+                const respHeadersRef = [null];
+                RfcGetTable(response, sapStr('HEADER_FIELDS'), respHeadersRef, e);
+                const respHeadersTable = respHeadersRef[0];
+                if (respHeadersTable) {
+                    const rowCountPtr = [0];
+                    RfcGetRowCount(respHeadersTable, rowCountPtr, e);
+                    const rowCount = rowCountPtr[0];
+                    if (rowCount > 0) {
+                        RfcMoveToFirstRow(respHeadersTable, e);
+                        for (let i = 0; i < rowCount; i++) {
+                            const row = RfcGetCurrentRow(respHeadersTable, e);
+                            if (row) {
+                                const name = readStringField(row, 'NAME');
+                                const value = readStringField(row, 'VALUE');
+                                if (name) { responseHeaders[name.toLowerCase()] = value; }
+                            }
+                            if (i < rowCount - 1) { RfcMoveToNextRow(respHeadersTable, e); }
+                        }
+                    }
+                }
+
+                // MESSAGE_BODY (XSTRING)
+                responseBody = readXStringField(response, 'MESSAGE_BODY');
+            }
+
+            // Decode body as UTF-8 (ADT always returns XML / text)
+            const dataStr = responseBody.length > 0 ? responseBody.toString('utf8') : '';
+
+            // Extract CSRF token if present
+            if (responseHeaders['x-csrf-token']) {
+                this.csrfToken = responseHeaders['x-csrf-token'];
+            }
+
+            return {
+                status:     statusCode,
+                statusText: statusText,
+                headers:    responseHeaders,
+                data:       dataStr,
+            };
+
+        } finally {
+            RfcDestroyFunction(func, newErr());
+        }
+    }
+
+    /** Fetch a fresh CSRF token via GET /sap/bc/adt/discovery */
+    async fetchCsrfToken() {
+        console.log('[RFC] Fetching CSRF token...');
+        const resp = await this.callADT('GET', '/sap/bc/adt/discovery', {
+            'X-CSRF-Token': 'Fetch',
+            'Accept': 'application/atomsvc+xml',
+        }, null);
+        if (resp.headers['x-csrf-token']) {
+            this.csrfToken = resp.headers['x-csrf-token'];
+            console.log(`[RFC] CSRF token: ${this.csrfToken.substring(0, 15)}...`);
+        }
+    }
+
+    /**
+     * Call any RFC function module with simple string importing parameters
+     * and read table output parameters.
+     *
+     * @param {string} fmName        - Function module name (e.g. 'ZREAD_ABAP_SOURCE')
+     * @param {Object} importing     - Key/value pairs for IMPORTING params (strings)
+     * @param {string[]} tables      - Names of TABLES parameters to read
+     * @param {string[]} tableFields - Field names to try on each row (default: ['LINE'])
+     * @returns {Object}             - { [tableName]: string[] }
+     */
+    async callFM(fmName, importing = {}, tables = [], tableFields = ['LINE']) {
+        await this.connect();
+
+        const e = newErr();
+
+        const funcDesc = RfcGetFunctionDesc(this.conn, sapStr(fmName), e);
+        if (!funcDesc) {
+            throw new Error(`RfcGetFunctionDesc(${fmName}) failed (code=${e.code}): ${decodeU16Array(e.message)}`);
+        }
+
+        const func = RfcCreateFunction(funcDesc, e);
+        if (!func) {
+            throw new Error(`RfcCreateFunction(${fmName}) failed: ${decodeU16Array(e.message)}`);
+        }
+
+        try {
+            // Set IMPORTING parameters
+            for (const [name, value] of Object.entries(importing)) {
+                const v = String(value);
+                const rc = RfcSetString(func, sapStr(name), sapStr(v), v.length, e);
+                if (rc !== 0) {
+                    console.warn(`[RFC] RfcSetString(${name}) rc=${rc}: ${decodeU16Array(e.message)}`);
+                }
+            }
+
+            // Invoke the function module
+            const invokeErr = newErr();
+            const rc = RfcInvoke(this.conn, func, invokeErr);
+            if (rc !== 0) {
+                const msg = decodeU16Array(invokeErr.message);
+                // Reset connection on communication or system failure
+                if (invokeErr.code === 1 || invokeErr.code === 3) { this.conn = null; }
+                throw new Error(`${fmName} failed (rc=${rc} code=${invokeErr.code}): ${msg}`);
+            }
+
+            // Read output TABLES parameters
+            const result = {};
+            for (const tableName of tables) {
+                const tableRef = [null];
+                const getTableErr = newErr();
+                const rcGetTable = RfcGetTable(func, sapStr(tableName), tableRef, getTableErr);
+                if (rcGetTable !== 0) {
+                    console.log(`[RFC] RfcGetTable(${tableName}) rc=${rcGetTable} code=${getTableErr.code}: ${decodeU16Array(getTableErr.message)}`);
+                }
+                const tableHandle = tableRef[0];
+                const lines = [];
+
+                if (tableHandle) {
+                    const rowCountErr = newErr();
+                    const rowCountPtr = [0];
+                    RfcGetRowCount(tableHandle, rowCountPtr, rowCountErr);
+                    const rowCount = rowCountPtr[0];
+                    console.log(`[RFC] Table ${tableName}: ${rowCount} row(s) returned`);
+                    // Iterate via cursor (don't trust rowCount alone — walk until move fails)
+                    let moveRc = RfcMoveToFirstRow(tableHandle, rowCountErr);
+                    let idx = 0;
+                    while (moveRc === 0) {
+                        const row = RfcGetCurrentRow(tableHandle, rowCountErr);
+                        if (!row) { break; }
+                        // tableFields=['LINE'] → hint=null (auto-discover or flat fallback)
+                        // tableFields=[...] with real names → use as hint (skip introspection)
+                        const hint = (tableFields.length === 1 && tableFields[0] === 'LINE')
+                            ? null
+                            : tableFields;
+                        const value = readAllFields(row, hint);
+                        if (idx === 0) {
+                            console.log(`[RFC]   row[0] value="${value.substring(0, 120)}"`);
+                        }
+                        lines.push(value);
+                        idx++;
+                        moveRc = RfcMoveToNextRow(tableHandle, rowCountErr);
+                    }
+                } else {
+                    console.log(`[RFC] Table ${tableName}: handle is NULL — parameter not found in FM ${fmName}`);
+                }
+
+                result[tableName] = lines;
+            }
+
+            // If we asked for tables but none returned any rows, dump the FM signature
+            // so it's obvious whether the parameter names match what SAP exports.
+            const askedAny = tables.length > 0;
+            const gotAny  = tables.some(t => (result[t] || []).length > 0);
+            if (askedAny && !gotAny) {
+                try {
+                    const countPtr = [0];
+                    const errInspect = newErr();
+                    if (RfcGetParameterCount(funcDesc, countPtr, errInspect) === 0) {
+                        console.log(`[RFC] Diagnostic — ${fmName} parameters as SAP reports them:`);
+                        for (let i = 0; i < countPtr[0]; i++) {
+                            const desc = {
+                                name: new Array(31).fill(0),
+                                type: 0, direction: 0, nucLength: 0, ucLength: 0, decimals: 0,
+                                typeDescHandle: null,
+                                defaultValue: new Array(31).fill(0),
+                                parameterText: new Array(80).fill(0),
+                                optional: 0,
+                                extendedDescription: null,
+                            };
+                            if (RfcGetParameterDescByIndex(funcDesc, i, desc, errInspect) === 0) {
+                                const pname = decodeU16Array(desc.name);
+                                const pdir  = RFC_DIRECTION_NAMES[desc.direction] || `dir=${desc.direction}`;
+                                const ptype = RFC_TYPE_NAMES[desc.type] || `type=${desc.type}`;
+                                console.log(`  [${i}] ${pdir.padEnd(8)} ${pname.padEnd(30)} ${ptype}`);
+                            }
+                        }
+                    }
+                } catch { /* diagnostic best effort */ }
+            }
+
+            return result;
+
+        } finally {
+            RfcDestroyFunction(func, newErr());
+        }
+    }
+
+    /**
+     * Fallback: set flat IMPORTING parameters (no REQUEST wrapper).
+     * Used if the function module doesn't have a top-level REQUEST structure.
+     */
+    _setFlatParams(func, method, uri, headers, body, e) {
+        const reqLineRef = [null];
+        RfcGetStructure(func, sapStr('REQUEST_LINE'), reqLineRef, e);
+        const reqLine = reqLineRef[0];
+        if (reqLine) {
+            RfcSetString(reqLine, sapStr('METHOD'),  sapStr(method),     method.length,    e);
+            RfcSetString(reqLine, sapStr('URI'),     sapStr(uri),        uri.length,       e);
+            RfcSetString(reqLine, sapStr('VERSION'), sapStr('HTTP/1.1'), 'HTTP/1.1'.length, e);
+        }
+
+        const headerTableRef = [null];
+        RfcGetTable(func, sapStr('HEADER_FIELDS'), headerTableRef, e);
+        const headerTable = headerTableRef[0];
+        if (headerTable) {
+            for (const [name, value] of Object.entries(headers || {})) {
+                const row = RfcAppendNewRow(headerTable, e);
+                if (row) {
+                    const v = String(value);
+                    RfcSetString(row, sapStr('NAME'),  sapStr(name), name.length, e);
+                    RfcSetString(row, sapStr('VALUE'), sapStr(v),    v.length,    e);
+                }
+            }
+        }
+
+        if (body && body.length > 0) {
+            const bodyBuf = Buffer.isBuffer(body) ? body : Buffer.from(body, 'utf8');
+            RfcSetXString(func, sapStr('MESSAGE_BODY'), bodyBuf, bodyBuf.length, e);
+        }
+    }
+}