@mcp-abap-adt/sap-rfc-lite 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to `@mcp-abap-adt/sap-rfc-lite` are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+Releases before 0.2.0 were not recorded here.
+
+## [0.2.0] - 2026-09-27
+
+### Added
+
+- **`client.resetServerContext(): Promise<void>`** wraps the SDK's
+  `RfcResetServerContext`. It ends the ABAP session context the connection
+  holds and keeps the connection open, so the next call runs in a fresh
+  context without a new logon.
+
+  What the context held is gone after the reset, including enqueue locks and
+  program buffers. That is how a stateless call gets a clean session on a
+  connection that stays open.
+
+  Measured on E19 (SAP_BASIS 816) through ADT's `SADT_REST_RFC_ENDPOINT`:
+  - Without a reset, a package created or written on a kept connection could
+    not be written there again (400 PAK/058, `CL_PACKAGE`'s session buffer).
+  - With a reset after each call, create, read, two writes and a delete all
+    passed on one connection.
+  - A reset costs about 0.1 s. Opening a new connection for each call costs
+    about 0.5 s.
+
+[0.2.0]: https://github.com/fr0ster/sap-rfc-lite/releases/tag/v0.2.0

package/NOTICE

@@ -0,0 +1,5 @@
+This project is based on node-rfc (https://github.com/SAP/node-rfc)
+Copyright 2014 SAP SE, Srdjan Boskovic <srdjan.boskovic@sap.com>
+Licensed under the Apache License, Version 2.0
+
+Modifications: Removed Pool, Server, Throughput classes. Simplified Client API to Promise-only.

package/README.md

@@ -0,0 +1,150 @@
+# sap-rfc-lite
+[![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/badges/StandWithUkraine.svg)](https://stand-with-ukraine.pp.ua)
+
+Lightweight Node.js bindings for SAP NetWeaver RFC SDK.
+
+## Motivation
+
+The only existing open-source Node.js binding for SAP NW RFC SDK is [node-rfc](https://github.com/SAP/node-rfc) by SAP. While it served the community well, it has accumulated significant technical debt:
+
+- **24 known vulnerabilities** (5 low, 7 moderate, 12 high) in its dependency tree
+- **18 outdated packages**, including runtime dependencies like `bluebird` (a Promise library unnecessary since Node.js 8+) and `decimal.js`
+- **Repository archived** — the source has moved to [SAP-archive/node-rfc](https://github.com/SAP-archive/node-rfc), signaling deprecation
+- **Last published 2+ years ago** with no signs of active maintenance
+- **~14,000 lines of source code** for what is fundamentally an RFC client binding
+
+SAP has since created a proprietary replacement (`@sap-rfc/node-rfc-library`), but it is only available through a private npm registry and requires an S-user with a SAP Build Code license — making it inaccessible to the broader community.
+
+No other lightweight alternative exists in the Node.js ecosystem. The only other package, [sapnwrfc](https://www.npmjs.com/package/sapnwrfc), was last published over 10 years ago.
+
+### Comparison
+
+| | sap-rfc-lite | node-rfc |
+|---|---|---|
+| Source code | ~2,200 lines | ~14,200 lines |
+| Runtime dependencies | 2 | 4 (includes bluebird, decimal.js) |
+| Vulnerabilities (npm audit) | **0** | **24** |
+| Outdated packages | 4 (dev only) | 18 (including runtime) |
+| API | Promise-based Client | Client, Pool, Server, Throughput |
+| Node.js requirement | >= 18 | >= 18 |
+| N-API version | 8 | 8 |
+
+This project focuses on what most users actually need — a clean, modern, Promise-based RFC client — without the baggage of unused features and vulnerable dependencies.
+
+## Prerequisites
+
+- Node.js >= 18
+- SAP NetWeaver RFC SDK installed
+- C++ build tools (Visual Studio Build Tools on Windows, GCC/Clang on Linux/macOS)
+
+Set the `SAPNWRFC_HOME` environment variable to the SDK root directory (the folder containing `lib/` and `include/`).
+
+## Installation
+
+```bash
+npm install @mcp-abap-adt/sap-rfc-lite
+```
+
+## Runtime library loading
+
+The addon is linked against the SDK shared libraries (`libsapnwrfc`, `libsapucum`) and, on Linux, the system `libuuid`. The dynamic loader must find all of them when the addon is loaded.
+
+On Linux and macOS the build embeds an rpath to `$SAPNWRFC_HOME/lib`, so the SDK libraries are found without extra settings as long as the SDK stays where it was at build time. Set the library search path when:
+
+- the SDK was moved, or the built addon is deployed to a machine where the SDK lives elsewhere;
+- Node.js ships its own glibc and does not search the system library directories (for example, Node.js installed via Homebrew on Linux). Loading then fails with `ERR_DLOPEN_FAILED` and `libuuid.so.1: cannot open shared object file`.
+
+| OS | Variable |
+|---|---|
+| Linux | `LD_LIBRARY_PATH` |
+| macOS | `DYLD_LIBRARY_PATH` |
+| Windows | `PATH` (must include `%SAPNWRFC_HOME%\lib`) |
+
+```bash
+# SDK moved or deployed elsewhere
+export LD_LIBRARY_PATH="$SAPNWRFC_HOME/lib:$LD_LIBRARY_PATH"
+```
+
+For a Node.js with its own glibc, do **not** add the whole system library directory (`/lib/x86_64-linux-gnu`): the loader would then take the system glibc, which may be older than the one Node.js was built against (`GLIBC_2.38 not found`). Expose only the missing library instead:
+
+```bash
+mkdir -p ~/.local/lib/sap-rfc-lite
+ln -sf /lib/x86_64-linux-gnu/libuuid.so.1 ~/.local/lib/sap-rfc-lite/
+export LD_LIBRARY_PATH="$HOME/.local/lib/sap-rfc-lite:$SAPNWRFC_HOME/lib:$LD_LIBRARY_PATH"
+```
+
+`binding.bindingVersions` reports the package version and the loaded SDK version, which is a quick check that the addon loads:
+
+```bash
+node -e "console.log(require('@mcp-abap-adt/sap-rfc-lite').binding.bindingVersions)"
+```
+
+## Usage
+
+```typescript
+import { Client } from '@mcp-abap-adt/sap-rfc-lite';
+
+const client = new Client({
+  ashost: '10.0.0.1',
+  sysnr: '00',
+  client: '100',
+  user: 'USER',
+  passwd: 'PASSWORD',
+  lang: 'EN',
+});
+
+await client.open();
+
+const result = await client.call('STFC_CONNECTION', {
+  REQUTEXT: 'Hello from sap-rfc-lite',
+});
+
+console.log(result.ECHOTEXT);
+
+await client.close();
+```
+
+## API
+
+### `new Client(connectionParameters)`
+
+Creates a new RFC client instance.
+
+- `connectionParameters` — an object with SAP connection parameters (`ashost`, `sysnr`, `client`, `user`, `passwd`, `lang`, etc.)
+
+### `client.open(): Promise<Client>`
+
+Opens the RFC connection.
+
+### `client.call(rfmName, rfmParams?): Promise<RfcObject>`
+
+Invokes a remote function module.
+
+- `rfmName` — name of the function module
+- `rfmParams` — optional input parameters
+
+### `client.resetServerContext(): Promise<void>`
+
+Resets the ABAP session context the connection holds and keeps the connection
+open (`RfcResetServerContext`). The next call runs in a fresh context, without
+a new logon.
+
+Everything the context held goes with it, including enqueue locks and program
+buffers. This is how a stateless call gets a clean session on a connection
+that is kept open.
+
+### `client.close(): Promise<void>`
+
+Closes the RFC connection.
+
+### `client.id: number`
+
+Unique client instance identifier.
+
+### `client.alive: boolean`
+
+Whether the connection is currently open.
+
+## License
+
+[Apache-2.0](LICENSE)

package/binding.gyp

@@ -13,6 +13,7 @@
         'nwrfcsdk_lib_dir': '<(nwrfcsdk_dir)/lib',
         'napi_include_dir': "<!(node -p \"require('node-addon-api').include_dir\")",
         'napi_version': "<!(node -p \"require('./package.json').config.napi_version\")",
+        'package_version': "<!(node -p \"require('./package.json').version\")",
         'node_abi_version': '<!(node -p "process.versions.modules")',
         # per NodeJS build requirements: https://github.com/nodejs/node/blob/main/BUILDING.md
         'macosx_version_min': '10.15',
@@ -92,6 +93,7 @@
                 'SAPwithTHREADS',
                 'NAPI_CPP_EXCEPTIONS',
                 'NAPI_VERSION=<(napi_version)',
+                'NODERFC_VERSION=<(package_version)',
                 'sapnwrfc_EXPORTS'
             ],
             'conditions': [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-abap-adt/sap-rfc-lite",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Lightweight Node.js bindings for SAP NW RFC SDK",
   "license": "Apache-2.0",
   "main": "./lib/index.js",
@@ -8,7 +8,9 @@
   "files": [
     "binding.gyp",
     "src",
-    "lib"
+    "lib",
+    "NOTICE",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "install": "node-gyp-build",
@@ -25,15 +27,15 @@
     "napi_version": 8
   },
   "dependencies": {
-    "node-addon-api": "^6.1.0",
+    "node-addon-api": "^8.9.2",
     "node-gyp-build": "^4.6.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.10",
-    "@types/jest": "^29.0.0",
+    "@biomejs/biome": "^2.5.14",
+    "@types/jest": "^30.0.0",
     "@types/node": "^20.0.0",
     "husky": "^9.1.7",
-    "jest": "^29.0.0",
+    "jest": "^30.5.1",
     "ts-jest": "^29.0.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.0.0"

package/src/cpp/Client.cc

@@ -48,6 +48,7 @@ Napi::Object Client::Init(Napi::Env env, Napi::Object exports) {
           InstanceAccessor("_alive", &Client::AliveGetter, nullptr),
           InstanceMethod("open", &Client::Open),
           InstanceMethod("close", &Client::Close),
+          InstanceMethod("resetServerContext", &Client::ResetServerContext),
           InstanceMethod("invoke", &Client::Invoke),
       });
 
@@ -186,6 +187,42 @@ class CloseAsync : public Napi::AsyncWorker {
   bool conn_closed = false;
 };
 
+// RfcResetServerContext: ends the ABAP session context ("user context") the
+// connection holds and keeps the connection open, so the next call runs in a
+// fresh context without a new logon.
+class ResetServerContextAsync : public Napi::AsyncWorker {
+ public:
+  ResetServerContextAsync(Napi::Function& callback, Client* client)
+      : Napi::AsyncWorker(callback), client(client) {}
+  ~ResetServerContextAsync() {}
+
+  void Execute() {
+    client->LockMutex();
+    conn_closed = (client->connectionHandle == nullptr);
+    if (!conn_closed) {
+      RfcResetServerContext(client->connectionHandle, &errorInfo);
+    }
+    client->UnlockMutex();
+  }
+
+  void OnOK() {
+    Napi::HandleScope scope(Env());
+    if (conn_closed) {
+      Callback().Call({client->connectionClosedError("resetServerContext()")});
+    } else if (errorInfo.code != RFC_OK) {
+      Callback().Call({rfcSdkError(&errorInfo)});
+    } else {
+      Callback().Call({});
+    }
+    Callback().Reset();
+  }
+
+ private:
+  Client* client;
+  RFC_ERROR_INFO errorInfo;
+  bool conn_closed = false;
+};
+
 class InvokeAsync : public Napi::AsyncWorker {
  public:
   InvokeAsync(Napi::Function& callback,
@@ -412,6 +449,18 @@ Napi::Value Client::Close(const Napi::CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
+Napi::Value Client::ResetServerContext(const Napi::CallbackInfo& info) {
+  if (!info[0].IsFunction()) {
+    Napi::TypeError::New(
+        info.Env(), "Client resetServerContext() requires a callback function")
+        .ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  }
+  Napi::Function callback = info[0].As<Napi::Function>();
+  (new ResetServerContextAsync(callback, this))->Queue();
+  return info.Env().Undefined();
+}
+
 Napi::Value Client::Invoke(const Napi::CallbackInfo& info) {
   Napi::Array notRequested = Napi::Array::New(info.Env());
   Napi::Value bcd;

package/src/cpp/Client.h

@@ -16,6 +16,7 @@ class Client : public Napi::ObjectWrap<Client> {
  public:
   friend class OpenAsync;
   friend class CloseAsync;
+  friend class ResetServerContextAsync;
   friend class PrepareAsync;
   friend class InvokeAsync;
   static Napi::Object Init(Napi::Env env, Napi::Object exports);
@@ -39,6 +40,7 @@ class Client : public Napi::ObjectWrap<Client> {
 
   Napi::Value Open(const Napi::CallbackInfo& info);
   Napi::Value Close(const Napi::CallbackInfo& info);
+  Napi::Value ResetServerContext(const Napi::CallbackInfo& info);
   Napi::Value Invoke(const Napi::CallbackInfo& info);
 
   RfmErrorPath errorPath;

package/src/cpp/addon.cc

@@ -21,7 +21,7 @@ Napi::Value BindingVersions(Napi::Env env) {
   nwrfcsdk.Set("patchLevel", patchLevel);
 
   Napi::Object version = Napi::Object::New(env);
-  version.Set("version", "0.1.0");
+  version.Set("version", NODERFC_VERSION_STRING);
   version.Set("nwrfcsdk", nwrfcsdk);
 
   return scope.Escape(version);

package/src/cpp/noderfc.h

@@ -17,8 +17,15 @@
 #define uint_t uint32_t
 #define pointer_t uintptr_t
 
-// client binding version
-#define NODERFC_VERSION "0.1.0"
+// client binding version, injected unquoted by binding.gyp from package.json
+// (stringified here to avoid platform-specific quoting of compiler defines)
+#define NODERFC_STRINGIFY_(x) #x
+#define NODERFC_STRINGIFY(x) NODERFC_STRINGIFY_(x)
+#ifdef NODERFC_VERSION
+#define NODERFC_VERSION_STRING NODERFC_STRINGIFY(NODERFC_VERSION)
+#else
+#define NODERFC_VERSION_STRING "unknown"
+#endif
 
 // surpress unused parameter warnings
 #define UNUSED(x) (void)(x)

package/src/ts/binding.ts

@@ -15,6 +15,7 @@ export interface RfcClientBinding {
   _alive: boolean;
   open(callback: (err?: unknown) => void): void;
   close(callback: (err?: unknown) => void): void;
+  resetServerContext(callback: (err?: unknown) => void): void;
   invoke(
     rfmName: string,
     rfmParams: RfcObject,

package/src/ts/client.ts

@@ -56,6 +56,25 @@ export class Client {
     });
   }
 
+  /**
+   * Resets the ABAP session context this connection holds and keeps the
+   * connection open (`RfcResetServerContext`). The next call runs in a fresh
+   * context without a new logon. Whatever the context held is gone, including
+   * enqueue locks and program buffers.
+   */
+  resetServerContext(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        this.__client.resetServerContext((err: unknown) => {
+          if (err === undefined) resolve();
+          else reject(err);
+        });
+      } catch (ex) {
+        reject(ex);
+      }
+    });
+  }
+
   call(rfmName: string, rfmParams: RfcObject = {}): Promise<RfcObject> {
     return new Promise((resolve, reject) => {
       if (typeof rfmName !== 'string' || rfmName.length === 0) {