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.
- Szenario 1: Login für Token, automatisch für die ganze Gruppe anhängen
- Szenario 2: Request-Body AES-verschlüsseln, Antwort entschlüsseln (Skriptkette)
- Szenario 3: Extraktion · Assertion · dynamische Variablen · Signatur
- Szenario 4: Gemeinsame Logik mit Bibliotheksskripten und
require()wiederverwenden
Die Beispiele nutzen den lokalen Testserver (
/oauth2/token,/protected,/echo,/jsonusw.). 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
| Aktion | Ergebnis |
|---|---|
| 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 senden | 401 (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 mitError: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, sonstTypeError); 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, Quelleresponse 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$jwtdegeneriert Objekt-Payloads zu[object Object](zuerst mitJSON.stringifystringifizieren 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 teiltglobalThismit den anderen Schritten. require(): Reine Funktionen in einer Skriptbibliothek mitmodule.exportsablegen 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ängen | Post-Response-Skript speichert + Pre-Send-Skript liest und injiziert den Header |
| Request-Body verschlüsseln / Antwort entschlüsseln | Pre-Send $crypto.encryptAES + Post-Response decryptAES |
| Ein Antwortfeld an den nächsten Request weitergeben | Extraktionsschritt + Skript, das die Variable liest |
| Statuscodes / Felder prüfen | Assertion-Schritt |
| Zufallswerte / Zeitstempel bei jedem Senden erzeugen | Dynamische Variablen wie {{$uuid}} |
| Eine offene API signieren | $hash.md5(...) (standardkonform) |
| Dieselbe Logik an vielen Stellen wiederverwenden | Bibliotheksskript, oder per require('@libs/<key>') eine Skriptbibliothek laden |