Zum Hauptinhalt springen

Klassische Szenario-Rezepte

Kombinieren Sie Kernkonzepte und Skripte zu echten Workflows. Jedes Szenario liefert: Ziel → Ablauf → direkt in die UI einfügbare Skripte → erwartetes Ergebnis. Sämtliche Skriptlogik wurde in der echten App end-to-end verifiziert.

Die Beispiele nutzen den lokalen Testserver (/oauth2/token, /protected, /echo, /json usw.). Ersetzen Sie Pfade und Pre-URLs durch Ihre eigenen, wenn Sie Ihre echten APIs ansteuern.


Szenario 1: Login für Token, automatisch für die ganze Gruppe anhängen​

Ziel: Die Login-API aufrufen, den Token speichern und dafür sorgen, dass jede nachfolgende Anfrage ihn automatisch anhängt — ohne manuelles Kopieren.

Request A — Login (Post-Response-Skript speichert den Token)​

POST /oauth2/token, Form-Body: grant_type=password&username=qruser&password=qrpass&client_id=qr-client&client_secret=qr-secret

Einen Skript-Schritt an die Post-Response-Kette anhängen:

async function onResponse(context, url, response) {
var j = response.body.parseJSON();
if (j && j.access_token) {
sdk.env.set('authToken', j.access_token); // store on the runtime blackboard
sdk.env.set('tokenType', j.token_type || 'Bearer');
}
return response;
}

Request B — Token anhängen (dasselbe Skript lässt sich in jede autorisierte API kopieren)​

GET /protected, einen Skript-Schritt an die Pre-Send-Kette anhängen:

async function onRequest(context, url, request) {
var tok = sdk.env.get('authToken'); // take from the blackboard
var ty = sdk.env.get('tokenType') || 'Bearer';
if (tok) { request.headers.set('Authorization', ty + ' ' + tok); }
return request;
}

Erwartetes Ergebnis​

AktionErgebnis
Zuerst A senden (Login)200, Antwort enthält access_token, Token gespeichert
Danach B senden (anhängen)200, Antwort {authorized:true, ...}
Skripte deaktivieren, B erneut senden401 (Pre-Send-Kette läuft nicht → kein Token injiziert — Beweis, dass das Skript ihn anhängt)

Schlüssel: A und B müssen in derselben Gruppe mit derselben Umgebung liegen (Laufzeitvariablen gelten pro Umgebung), und die Pfadfragmente werden durch die Umgebung-Pre-URL vervollständigt.


Szenario 2: Request-Body AES-verschlüsseln, Antwort entschlüsseln (Skriptkette)​

Ziel: Den Body vor dem Senden AES-verschlüsseln (nur Ciphertext auf der Leitung), die Antwort nach Ankunft entschlüsseln; zeigt außerdem die Verkettung mehrerer Skripte und den Datenaustausch zwischen ihnen.

Warum lässt sich das in mehrere Skripte aufteilen? Skripte derselben Kette teilen sich globalThis: Skript ① legt Schlüssel/Klartext ab, die Skripte ②③ greifen darauf zu. Jedes Skript bleibt zweckgebunden und lässt sich unabhängig ein-/ausschalten.

Pre-Send-Kette​

Skript ① (Kontext und Schlüssel vorbereiten):

async function onRequest(context, url, request) {
globalThis.__traceId = $uuid.v4();
globalThis.__aesKey = '0123456789abcdef'; // 16 bytes → AES-128
globalThis.__aesIv = 'abcdef0123456789';
globalThis.__plain = request.body.parseText();
request.headers.set('X-Trace-Id', globalThis.__traceId);
return request;
}

Skript ② (Body verschlüsseln):

async function onRequest(context, url, request) {
var cipher = $crypto.encryptAES(globalThis.__plain, globalThis.__aesKey, globalThis.__aesIv);
request.body = cipher; // only ciphertext on the wire
request.headers.set('X-Encrypt', 'AES-128-CBC');
return request;
}

(Optional) Skript ③ ergänzt die Logik zum Token-Anhängen aus Szenario 1.

Post-Response-Kette (entschlüsseln + Antwort umschreiben)​

async function onResponse(context, url, response) {
var j = response.body.parseJSON();
var cipher = j && j.body && j.body.utf8; // /echo echoes the request body in body.utf8
var recovered = cipher ? $crypto.decryptAES(cipher, globalThis.__aesKey, globalThis.__aesIv) : '';
var obj = null; try { obj = JSON.parse(recovered); } catch (e) {}
response.body = JSON.stringify({
traceId: globalThis.__traceId, decrypted: recovered,
roundtripOk: recovered === globalThis.__plain, jsonValid: !!obj,
});
return response;
}

Request-Body (vor der Verschlüsselung): {"order":123,"note":"secret-payload","amount":99.5}

Erwartetes Ergebnis​

Nach dem Senden erhalten Sie:

{"traceId":"...","decrypted":"{\"order\":123,\"note\":\"secret-payload\",\"amount\":99.5}","roundtripOk":true,"jsonValid":true}
  • roundtripOk:true: Das entschlüsselte Ergebnis stimmt byteweise mit dem ursprünglichen Klartext überein
  • Der umgeschriebene Response-Body ist im Ergebnis sichtbar (Beweis, dass die Post-Response-Umschreibung wirkt)

⚠️ $crypto-Argumente sind positionale Strings; bei Fehlern wird nur ein String beginnend mit Error: zurückgegeben — nicht geworfen und nicht abgebrochen (verifiziert: schlechter Ciphertext → Invalid ciphertext, falscher key/iv → CryptoKit error). Chinesischer / nicht-ASCII-Klartext wird korrekt ver- und entschlüsselt (die alte Behauptung „nicht-ASCII bricht ab“ ist widerlegt). Wenn Sie ein entschlüsseltes Ergebnis in einen HTTP-Header schreiben wollen, muss der Wert ASCII sein (Headerwerte lehnen Nicht-ASCII ab, sonst TypeError); UTF-8-Inhalte gehören in Body oder Query-Parameter.


Szenario 3: Extraktion · Assertion · dynamische Variablen · Signatur​

Ein Satz leichtgewichtiger Automatisierungen — die meisten brauchen gar kein JS, sondern deklarative Extraktions- / Assertions-Schritte.

3.1 Ein Antwortfeld an den nächsten Request weitergeben (Extraktion)​

  • Einen Extraktions-Schritt an die Post-Response-Kette von Request A hängen: Variable author, Quelle response body JSON, Ausdruck $.slideshow.author.
  • Einen Skript-Schritt an die Pre-Send-Kette von Request B hängen: var v=sdk.env.get('author'); if(v){ request.headers.set('X-Extracted', v); } return request;

Verifiziert: Der /echo-Aufruf von Request B spiegelt einen X-Extracted-Header, der zum Autor in der Antwort von Request A passt.

3.2 Assertions​

Assertions-Schritte an die Post-Response-Kette hängen: Statuscode = 200, $.slideshow.title exists. Die Ergebnisse werden einzeln aufgelistet (bestanden/fehlgeschlagen, erwartet vs. tatsächlich).

3.3 Dynamische Variablen​

Direkt in Params / Headers / URL schreiben:

GET /echo?ts={{$timestamp}}&r={{$randomInt}}&u={{$uuid}}

Verifiziert: Jedes Senden spiegelt ts als aktuellen Zeitstempel, r als eine andere Zufallszahl und u als gültige UUID. Vollständige Liste: Kernkonzepte, dynamische Variablen.

3.4 Signatur (MD5, Standard und interoperabel)​

Viele offene APIs signieren mit MD5(param concatenation + secret). Verwenden Sie den verifiziert standardkonformen $hash.md5:

async function onRequest(context, url, request) {
var appId = sdk.env.get('appId');
var secret = sdk.env.get('appSecret'); // keep secrets in environment variables
var ts = String(Math.floor(Date.now() / 1000));
var sign = $hash.md5(appId + ts + secret); // concatenation order per your backend's convention
request.queries.set('appId', appId);
request.queries.set('ts', ts);
request.queries.set('sign', sign);
return request;
}

Verifiziert: $hash.md5('abc') = 900150983cd24fb0d6963f7d28e17f72, deckungsgleich mit dem Backend.

✅ Das native $hmac ($hmac.sha256(message, key) usw.) wurde vektorweise gegen standardkonformes RFC-HMAC verifiziert (Achtung Argumentreihenfolge: erst Daten, dann Schlüssel) und ist für externe Signaturen geeignet; auch die $hash-Familie ist standardkonform. Nur $jwt degeneriert Objekt-Payloads zu [object Object] (zuerst mit JSON.stringify stringifizieren oder serverseitig signieren).


Szenario 4: Gemeinsame Logik mit Bibliotheksskripten und require() wiederverwenden​

Ziel: „Token injizieren“, „vereinheitlichte Signatur“ und „Logging“ als wiederverwendbare Einheiten auslagern — an vielen Stellen referenzieren, an einer pflegen.

Zwei Wege zur Wiederverwendung:

  • Bibliotheksskript-Schritt: Ein vollständiges Skript mit eigenem onRequest/onResponse — als Schritt angehängt läuft es der Reihe nach und teilt globalThis mit den anderen Schritten.
  • require(): Reine Funktionen in einer Skriptbibliothek mit module.exports ablegen und aus jedem Skript laden — ideal für Signaturhelfer, Codecs und andere Gemeinsamkeiten:
// script library "sign-lib" (no entry function needed)
function sign(method, path, body, secret) {
return $hmac.sha256(method + path + body, secret);
}
module.exports = { sign };
// any request script
async function onRequest(context, url, request) {
const { sign } = require('@libs/sign-lib');
request.headers.set('X-Sign', sign('POST', request.path, request.body.parseText(), sdk.env.get('appSecret')));
return request;
}

Im Bibliotheksmanager Copy require statement verwenden, um die stabile Identifier-Form zu bekommen. Eingebaute Bibliotheken (@libs/base64, @libs/hex) sind überall ohne Einrichtung verfügbar. Die vollständige Mechanik: Skripte, Require-Script-Libraries.


Szenario-Spickzettel​

Ich möchte…Welche Schritte
Nach dem Login den Token an jede API automatisch anhängenPost-Response-Skript speichert + Pre-Send-Skript liest und injiziert den Header
Request-Body verschlüsseln / Antwort entschlüsselnPre-Send $crypto.encryptAES + Post-Response decryptAES
Ein Antwortfeld an den nächsten Request weitergebenExtraktionsschritt + Skript, das die Variable liest
Statuscodes / Felder prüfenAssertion-Schritt
Zufallswerte / Zeitstempel bei jedem Senden erzeugenDynamische Variablen wie {{$uuid}}
Eine offene API signieren$hash.md5(...) (standardkonform)
Dieselbe Logik an vielen Stellen wiederverwendenBibliotheksskript, oder per require('@libs/<key>') eine Skriptbibliothek laden