@mcp-abap-adt/sap-rfc-lite 0.1.2 → 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/README.md

@@ -123,6 +123,16 @@ 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-abap-adt/sap-rfc-lite",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Lightweight Node.js bindings for SAP NW RFC SDK",
   "license": "Apache-2.0",
   "main": "./lib/index.js",
@@ -9,7 +9,8 @@
     "binding.gyp",
     "src",
     "lib",
-    "NOTICE"
+    "NOTICE",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "install": "node-gyp-build",

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/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) {