Ga naar hoofdinhoud

Klassieke scenario-recepten

Combineer concepts en scripting tot praktische workflows. Elk scenario geeft: doel → stroom → scripts die je direct in de UI kunt plakken → verwacht resultaat. Alle scriptlogica is end-to-end geverifieerd in de echte app.

De voorbeelden gebruiken de lokale testserver (/oauth2/token, /protected, /echo, /json, enz.). Vervang ze door je eigen paden en Pre-URL's zodra je je eigen API's aanspreekt.


Scenario 1: inloggen voor de token, automatisch toevoegen voor de hele groep​

Doel: de login-API aanroepen, de token opslaan en elk volgende verzoek de token automatisch laten bijvoegen — zonder handmatig kopiëren.

Verzoek A — login (het script na het antwoord slaat de token op)​

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

Voeg één script-stap toe aan de keten na het antwoord:

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;
}

Verzoek B — de token bijvoegen (hetzelfde script kun je kopiëren naar elke geautoriseerde API)​

GET /protected, voeg één script-stap toe aan de keten vóór verzending:

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;
}

Verwacht resultaat​

ActieResultaat
Verstuur eerst A (login)200, het antwoord bevat access_token, de token is opgeslagen
Verstuur daarna B (bijvoegen)200, antwoord {authorized:true, ...}
Schakel scripts uit en verstuur B opnieuw401 (de keten vóór verzending draait niet → er wordt geen token geïnjecteerd — het bewijs dat het script de token bijvoegt)

Belangrijk: A en B moeten in dezelfde groep zitten die aan dezelfde omgeving is gekoppeld (runtime-variabelen zijn per omgeving afgebakend), en padfragmenten worden aangevuld door de Pre-URL van de omgeving.


Scenario 2: de body van het verzoek versleutelen met AES, het antwoord ontsleutelen (keten met meerdere scripts)​

Doel: de body vóór verzending met AES versleutelen (op de draad komt alleen ciphertext aan), het antwoord na aankomst ontsleutelen; demonstreert ook het ketenen van meerdere scripts en het delen van gegevens tussen ze.

Waarom kun je dit opsplitsen in meerdere scripts? Scripts in dezelfde keten delen globalThis: script ① bergt de sleutels/plaintext op, scripts ②③ halen ze er weer uit. Elk script blijft één doel dienen en kan onafhankelijk worden in- of uitgeschakeld.

Keten vóór verzending​

Script ① (maakt context en sleutels aan):

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;
}

Script ② (versleutelt de body):

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;
}

(Optioneel) script ③ voegt de logica voor het bijvoegen van de token uit Scenario 1 toe.

Keten na het antwoord (ontsleutelen + het antwoord herschrijven)​

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;
}

Verzoek-body (vóór versleuteling): {"order":123,"note":"secret-payload","amount":99.5}

Verwacht resultaat​

Na het verzenden krijg je:

{"traceId":"...","decrypted":"{\"order\":123,\"note\":\"secret-payload\",\"amount\":99.5}","roundtripOk":true,"jsonValid":true}
  • roundtripOk:true: het ontsleutelde resultaat komt byte voor byte overeen met de oorspronkelijke plaintext
  • De herschreven antwoord-body is zichtbaar in het resultaat (bewijs dat het herschrijven na het antwoord werkelijk effect heeft)

⚠️ $crypto-argumenten zijn positionele strings; bij een fout geeft het alleen een string terug die begint met Error: — er wordt geen exceptie gegooid en het script breekt niet af (geverifieerd: slechte ciphertext → Invalid ciphertext, verkeerde key/iv → CryptoKit error). Chinese / niet-ASCII plaintext kan correct worden versleuteld én ontsleuteld (de oude bewering dat 'niet-ASCII afbreekt' is weerlegd). Als je een ontsleuteld resultaat in een HTTP-header wilt schrijven, zorg er dan voor dat de waarde ASCII is (headervalue's wijzen niet-ASCII af, anders wordt een TypeError gegooid); zet UTF-8-inhoud liever in de body of de query-parameters.


Scenario 3: extractie · asserties · dynamische variabelen · ondertekening​

Een reeks lichtgewicht automatiseringen — de meeste vereisen helemaal geen JavaScript en gebruiken declaratieve extractie-/assertie-stappen.

3.1 Een antwoordveld doorgeven aan het volgende verzoek (extractie)​

  • Voeg een extractie-stap toe aan de keten na het antwoord van verzoek A: variabele author, bron response body JSON, expressie $.slideshow.author.
  • Voeg een script-stap toe aan de keten vóór verzending van verzoek B: var v=sdk.env.get('author'); if(v){ request.headers.set('X-Extracted', v); } return request;

Geverifieerd: het /echo-antwoord van verzoek B bevat een X-Extracted-header die overeenkomt met de author-waarde uit het antwoord van verzoek A.

3.2 Asserties​

Voeg assertie-stappen toe aan de keten na het antwoord: statuscode = 200, $.slideshow.title exists. De resultaten worden één voor één opgesomd (geslaagd/gefaald, verwacht versus werkelijk).

3.3 Dynamische variabelen​

Schrijf ze direct in params / headers / URL:

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

Geverifieerd: bij elke verzending komt ts terug als de huidige tijdstempel, r als een ander willekeurig geheel getal en u als een geldige UUID. Volledige lijst: concepts, dynamische variabelen.

3.4 Ondertekening (MD5, standaard en interoperabel)​

Veel open API's ondertekenen met MD5(param concatenation + secret). Gebruik de geverifieerd-standaard $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;
}

Geverifieerd: $hash.md5('abc') = 900150983cd24fb0d6963f7d28e17f72, in overeenstemming met de backend.

✅ De native $hmac ($hmac.sha256(message, key) enz.) is vector voor vector geverifieerd als overeenkomend met de standaard RFC HMAC (let op de argumentvolgorde: eerst de data, dan de key) en kan worden gebruikt voor ondertekening naar buiten; ook de $hash-familie is standaard. Alleen $jwt degradeert object-payloads naar [object Object] (maak eerst een string met JSON.stringify, of onderteken op de server).


Scenario 4: gedeelde logica hergebruiken met bibliotheekscripts en require()​

Doel: 'token injecteren', 'uniforme ondertekening' en 'logging' extraheren tot herbruikbare eenheden — op veel plaatsen verwijzen, op één plaats onderhouden.

Twee manieren om te hergebruiken:

  • Bibliotheekscript-stap: een compleet script met zijn eigen onRequest/onResponse — voeg het als stap toe en het draait in volgorde, met globalThis gedeeld met de andere stappen.
  • require(): bewaar pure functies in een scriptbibliotheek met module.exports en laad ze vanuit elk script — ideaal voor ondertekeningshulpjes, codecs en andere gedeelde hulpmiddelen:
// 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;
}

Gebruik Require-instructie kopiëren in de bibliotheekbeheerder voor de vorm met de stabiele identificator. Ingebouwde bibliotheken (@libs/base64, @libs/hex) zijn overal beschikbaar zonder installatie. Volledige werking: scripting, Scriptbibliotheken laden met require().


Spiekbriefje voor scenario's​

Ik wil…Welke stappen
Na de login automatisch de token bijvoegen op elke APIHet script na het antwoord slaat op + het script vóór verzending leest en injecteert de header
De verzoek-body versleutelen / het antwoord ontsleutelenVóór verzending $crypto.encryptAES + na het antwoord decryptAES
Een antwoordveld doorgeven aan het volgende verzoekExtractie-stap + script dat de variabele leest
Statuscodes / velden validerenAssertie-stap
Bij elke verzending willekeurige waarden / tijdstempels genererenDynamische variabelen zoals {{$uuid}}
Een open API ondertekenen$hash.md5(...) (standaard)
Dezelfde logica op veel plaatsen hergebruikenBibliotheekscript, of require('@libs/<key>') met een scriptbibliotheek