Gå til hovedinnhold

Klassiske scenariooppskrifter

Kombiner konsepter og scripting til arbeidsflyter fra virkeligheten. Hvert scenario gir: mål → flyt → skript du kan lime rett inn i UI → forventet resultat. All skriptlogikk er verifisert ende-til-ende i den ekte appen.

Eksemplene bruker den lokale testserveren (/oauth2/token, /protected, /echo, /json, osv.). Bytt inn dine egne stier og Pre-URL-er når du peker på dine egne API-er.


Scenario 1: Innlogging for token, automatisk vedlegg for hele gruppen​

Mål: kall innloggings-API-et, lagre tokenet, og la hver påfølgende forespørsel legge det ved automatisk — ingen manuell kopiering.

Forespørsel A — innlogging (skriptet etter svar lagrer tokenet)​

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

Legg til ett skript-trinn i kjeden etter svar:

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

Forespørsel B — legg ved tokenet (samme skript kan kopieres til hvert autoriserte API)​

GET /protected, legg til ett skript-trinn i kjeden før sending:

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

Forventet resultat​

HandlingResultat
Send A først (innlogging)200, svaret inneholder access_token, tokenet lagres
Send deretter B (vedlegg)200, svar {authorized:true, ...}
Deaktiver skript, send B igjen401 (kjeden før sending kjører ikke → ingen token injisert — bevis på at det er skriptet som legger det ved)

Nøkkelen: A og B må være i samme gruppe bundet til samme miljø (kjøretidsvariabler er omfattet per miljø), og sti-fragmentene fullføres av miljøets Pre-URL.


Scenario 2: AES-krypter request-bodyen, dekrypter svaret (flerskriptkjede)​

Mål: krypter bodyen med AES før sending (kun ciphertext på ledningen), dekrypter svaret etter ankomst; demonstrerer også kobling av flere skript og deling av data mellom dem.

Hvorfor kan det deles opp i flere skript? Skript i samme kjede deler globalThis: skript ① stasjer nøkler/klartekst, skript ②③ plukker dem opp. Hvert skript forblir enkeltformål og kan slås av/på uavhengig.

Kjeden før sending​

Skript ① (forbered kontekst og nøkler):

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 ② (krypter bodyen):

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

(Valgfritt) skript ③ legger til token-vedleggslogikken fra Scenario 1.

Kjeden etter svar (dekrypter + omskriv svaret)​

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 (før kryptering): {"order":123,"note":"secret-payload","amount":99.5}

Forventet resultat​

Etter sending får du:

{"traceId":"...","decrypted":"{\"order\":123,\"note\":\"secret-payload\",\"amount\":99.5}","roundtripOk":true,"jsonValid":true}
  • roundtripOk:true: det dekrypterte resultatet matcher original klartekst byte for byte
  • Den omskrevne respons-bodyen er synlig i resultatet (bevis på at omskrivingen etter svar virket)

⚠️ $crypto-argumenter er posisjonelle strenger; ved feil returnerer den bare en streng som starter med Error: — den kaster ikke eller avbryter (verifisert: dårlig ciphertext → Invalid ciphertext, feil key/iv → CryptoKit error). Kinesisk / ikke-ASCII klartekst krypteres og dekrypteres korrekt (det gamle utsagnet om at «ikke-ASCII avbryter» er motbevist). Skal du skrive et dekryptert resultat inn i en HTTP-header, sørg for at verdien er ASCII (headerverdier avviser ikke-ASCII, ellers kastes TypeError); legg heller UTF-8-innhold i body eller query-parametere.


Scenario 3: Uttrekk · assertion · dynamiske variabler · signering​

Et sett med lette automatiseringer — de fleste trenger ingen JS i det hele tatt, ved hjelp av deklarative extract / assert-trinn.

3.1 Overfør et responsfelt til neste forespørsel (extract)​

  • Legg til et extract-trinn i forespørsel A sin kjede etter svar: variabel author, kilde response body JSON, uttrykk $.slideshow.author.
  • Legg til et skript-trinn i forespørsel B sin kjede før sending: var v=sdk.env.get('author'); if(v){ request.headers.set('X-Extracted', v); } return request;

Verifisert: /echo for forespørsel B gjenkaster en X-Extracted-header som matcher author i forespørsel A sitt svar.

3.2 Assertion​

Legg til assert-trinn i kjeden etter svar: statuskode = 200, $.slideshow.title exists. Resultatene listes opp én etter én (bestått/feilet, forventet vs faktisk).

3.3 Dynamiske variabler​

Skriv dem rett inn i params / headers / URL:

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

Verifisert: hver sending gjenkaster ts som nåværende tidsstempel, r som et annet tilfeldig heltall, og u som en gyldig UUID. Full liste: konsepter, dynamiske variabler.

3.4 Signering (MD5, standard og interoperabel)​

Mange åpne API-er signerer med MD5(param concatenation + secret). Bruk $hash.md5 i verifisert standard:

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

Verifisert: $hash.md5('abc') = 900150983cd24fb0d6963f7d28e17f72, matcher backend.

✅ Den native $hmac ($hmac.sha256(message, key) osv.) er vektor-for-vektor verifisert å matche standard RFC HMAC (merk argumentrekkefølgen: data først, key som andre) og kan brukes til ekstern signering; $hash-familien er også standard. Bare $jwt degraderer objekt-payloads til [object Object] (stringify først med JSON.stringify, eller signer på serveren).


Scenario 4: Gjenbruk felles logikk med skriptbiblioteker og require()​

Mål: trekk ut «injiser token», «samlet signering» og «logging» som gjenbrukbare enheter — referer dem mange steder, vedlikehold dem ett sted.

To måter å gjenbruke på:

  • Skriptbibliotek-trinn: et fullt skript med egen onRequest/onResponse — legg det til som et trinn, så kjører det i rekkefølge og deler globalThis med de andre trinnene.
  • require(): lagre rene funksjoner i et skriptbibliotek med module.exports, og last dem fra hvilket som helst skript — best for signeringshjelpere, kodeker og andre felles verktøy:
// 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;
}

Bruk Copy require statement i bibliotekadministratoren for den stabile identifikatorformen. Innebygde biblioteker (@libs/base64, @libs/hex) er tilgjengelige overalt uten oppsett. Full mekanikk: scripting, Skriptbiblioteker med require.


Jukseark for scenarioer​

Jeg vil…Hvilke trinn
Legge ved tokenet automatisk på hvert API etter innloggingSkriptet etter svar lagrer + skriptet før sending leser og injiserer headeren
Kryptere request-body / dekryptere svaret$crypto.encryptAES før sending + decryptAES etter svar
Overføre et responsfelt til neste forespørselExtract-trinn + skript som leser variabelen
Validere statuskoder / feltAssert-trinn
Generere tilfeldige verdier / tidsstempler ved hver sendingDynamiske variabler som {{$uuid}}
Signere et åpent API$hash.md5(...) (standard)
Gjenbruke samme logikk mange stederSkriptbibliotek, eller require('@libs/<key>') et skriptbibliotek