Ga naar hoofdinhoud

Script-API-referentie

Hodor draait je scripts in een ingebouwde JavaScript-engine. Afhankelijk van het scripttype roept Hodor op het juiste moment een van de onderstaande entryfuncties aan — je implementeert alleen de logica die je nodig hebt. Als je niets wijzigt, verwijder dan de ongebruikte entryfunctie om onnodige aanroepen te vermijden.

Beschikbare globale objecten en klassen:

CategorieNamen
EntryfunctiesonRequest, onResponse, onSessionCompleted, onSchedule, abort()
Native $-modules$codec, $hash, $hmac, $crypto, $jwt, $format, $fs, $env, $uuid, $log
Web-standaard-API'sfetch, HTTPClient, setTimeout / setInterval, btoa / atob / sleep / require / TextEncoder / crypto, console
HTTP-klassenRequest, Response, Body, Headers, URLSearchParams
OpslagSharedPreferences, sdk-variabelen
ContextenRewriteContext, CompletedContext, ScheduleContext
tip

Gebruik console.log(...) op elke plek in een script om waarden te inspecteren — de uitvoer wordt getoond in de logweergave van het script.

Entryfuncties​

Scripts worden gedetecteerd door te scannen op async function-declaraties — het aantal parameters van elke entryfunctie is vast (onRequest/onResponse nemen er 3, onSessionCompleted 4, onSchedule 1). Pijlfunctie-toewijzingen (let onRequest = async (...) => {}) worden niet gedetecteerd. Parameternamen zijn vrij te kiezen.

onRequest(context, url, request)​

Ontworpen voor Rewrite Script en Quick Request-scripts vóór verzending. Deze functie wordt aangeroepen voordat het HTTP-verzoek naar de server wordt verzonden. Geef het (mogelijk gewijzigde) request terug.

ParameterTypeBeschrijving
contextRewriteContextHet contextobject.
urlstringDe URL van het HTTP-verzoek.
requestRequestHet HTTP-verzoekobject.
// modify request body
async function onRequest(context, url, request) {
// parse to Text
var text = request.body.parseText()
console.log(text)
request.body = "this is a replaced request text"

// parse to JSON
var json = request.body.parseJSON()
json["script_json"] = "JSONValue"
request.body = json

// parse to URLSearchParams
var urlencoded = request.body.parseURLSearchParams()
urlencoded.append("script", "parseURLSearchParams")
request.body = urlencoded
// Done
return request;
}
// redirect, modify path / queries / headers
async function onRequest(context, url, request) {
console.log(url);
// set a parameter, you can get it in onResponse
context.parameters["custom"] = "custom parameter on request"

// redirect
request.scheme = "http"
request.path = "/upload/json"
request.host = "192.168.3.30"
request.port = 6000
// change method
request.method = "POST"

// queries operation
request.queries.append("name", "value1") // add query
request.queries.set("name", "value2") // replace or add query
request.queries.get("name") // get query by name
request.queries.delete("name") // delete query by name

// headers operation
request.headers.delete("accept") // delete header by name
request.headers.append("hodor", "custom value") // add name-value pair
request.headers.forEach((value, name) => {
console.log(name + ":" + value)
});
// Done
return request;
}

onResponse(context, url, response)​

Ontworpen voor Rewrite Script en Quick Request-scripts na het antwoord. Deze functie wordt aangeroepen voordat het HTTP-antwoord naar de client wordt verzonden. Geef het (mogelijk gewijzigde) response terug.

ParameterTypeBeschrijving
contextRewriteContextHet contextobject.
urlstringDe URL van het HTTP-antwoord.
responseResponseHet HTTP-antwoordobject.
// response body
async function onResponse(context, url, response) {
// parse to Text
var text = response.body.parseText()
console.log(text)
response.body = "this is a replaced response text"

// parse to JSON
var json = response.body.parseJSON()
json["script_json"] = "JSONValue"
response.body = json

// parse to URLSearchParams
var urlencoded = response.body.parseURLSearchParams()
urlencoded.append("script", "parseURLSearchParams")
response.body = urlencoded
// Done
return response;
}
// change status code and headers
async function onResponse(context, url, response) {
// get parameters set in onRequest
console.log(context.parameters["custom"]) // Output "custom parameter on request"

response.statusCode = 200 // change status code
response.statusPhrase = "OK" // change status phrase

response.headers.delete("accept")
response.headers.append("hodor", "custom value")
response.headers.forEach((value, name) => {
console.log(name + ":" + value)
});
// Done
return response
}

onSessionCompleted(context, url, request, response)​

Ontworpen voor HTTP Completed Script. Wordt asynchroon aangeroepen nadat het HTTP-antwoord is teruggekomen, zonder de gegevensoverdracht tussen de app en de server te beïnvloeden. Nuttig voor het verzamelen en doorsturen van gegevens.

ParameterTypeBeschrijving
contextCompletedContextHet contextobject.
urlstringDe URL van het HTTP-verzoek.
requestRequestHet HTTP-verzoekobject.
responseResponseHet HTTP-antwoordobject.
// sample: pass session data to your own server
async function onSessionCompleted(context, url, request, response) {
try {
var reqText = request.body.parseText();
var rspText = response.body.parseText()
var params = {
"body": { // HTTPClient post body data
"url": url, // request url
"reqHeader": request.headers.encode(), // request headers
"reqText": reqText, // request body
"rspHeader": response.headers.encode(), // response headers
"rspText": rspText, // response body
},
"headers": { // HTTPClient headers
"from": "onSessionCompleted"
},
}
const rsp = await HTTPClient.post("http://192.168.3.30:8000/upload", params)
let text = rsp.body.parseText()
console.log(text)
} catch(error) {
console.log(error)
}
}

onSchedule(context)​

Ontworpen voor Schedule Script. Wordt aangeroepen op het geplande triggertijdstip (cron-expressies met 5 of 6 velden worden ondersteund). Gebruik abort() om de planningslus te stoppen.

ParameterTypeBeschrijving
contextScheduleContextHet contextobject.
async function onSchedule(context) {
// set custom parameters for next runloop
context.parameters["custom"] = "custom parameters for next runloop";
// repeated count
console.log(`repeatedCount ${context.repeatedCount}`);
// if repeatedCount is 2, abort schedule
if (context.repeatedCount == 2) {
abort()
}
// you can also use HTTPClient to send requests
const rsp = await HTTPClient.get("https://www.apple.com")
let text = rsp.body.parseText()
console.log(text)
}

abort()​

In kanaalscripts (onRequest / onResponse / onSchedule) roep je abort() aan om het script te stoppen en de huidige uitvoering onmiddellijk af te breken — het gooit een AbortError die Hodor aan jou rapporteert.

// ✅ correct — abort() is injected into the script scope
async function onRequest(context, url, request) {
if (url.includes("/tracking")) abort();
return request;
}
waarschuwing

Declareer onRequest(context, url, request, aborter) niet met een 4e parameter. Het aantal parameters van entryfuncties is vast — een 4e parameter maakt de entry ondetecteerbaar.

Native modules​

Alle modules met $-voorvoegsel worden geïnjecteerd zodra de runtime activeert. Ze zijn native geïmplementeerd, geven synchroon terug (tenzij anders vermeld) en behandelen string-invoer als UTF-8.

$codec — Encoderen & decoderen​

Base64 / Hex / URL-percent-encoding voor protocolconversie en gegevensoverdracht.

MethodeGeeft terug
$codec.base64Encode(str)Base64-string.
$codec.base64Decode(str)Gedecodeerde string; ongeldige invoer geeft "" terug (gooit geen exceptie).
$codec.hexEncode(str)Hex-string in kleine letters.
$codec.hexDecode(str)Gedecodeerde string; ongeldige tekens worden overgeslagen.
$codec.urlEncode(str)Percent-gecodeerde string.
$codec.urlDecode(str)Gedecodeerde string; ongeldige sequenties worden ongewijzigd teruggegeven.
$codec.base64Encode("Hello, World!"); // "SGVsbG8sIFdvcmxkIQ=="
$codec.base64Decode("SGVsbG8sIFdvcmxkIQ=="); // "Hello, World!"
$codec.hexEncode("ABC"); // "414243"
$codec.hexDecode("414243"); // "ABC"
$codec.urlEncode("hello world&foo=bar"); // "hello%20world%26foo%3Dbar"

$hash — Hashing​

Digestberekening voor integriteitscontroles, content addressing en anonimisering. Geeft hex in kleine letters terug.

MethodeUitvoerlengte
$hash.md5(str)32 hex-tekens
$hash.sha1(str)40 hex-tekens
$hash.sha256(str)64 hex-tekens
$hash.sha384(str)96 hex-tekens
$hash.sha512(str)128 hex-tekens
$hash.md5("hello"); // "5d41402abc4b2a76b9719d911017c592"
$hash.sha256("hello"); // "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"

// integrity check
const checksum = $hash.sha256(JSON.stringify({user: "admin"}));

$hmac — Message Authentication Code​

Keyed hashing voor API-ondertekening en manipulatiedetectie. Zowel (data, key) zijn UTF-8-gecodeerd; geeft hex in kleine letters terug.

MethodeAlgoritme
$hmac.md5(data, key)HMAC-MD5
$hmac.sha1(data, key)HMAC-SHA1
$hmac.sha256(data, key)HMAC-SHA256
$hmac.sha384(data, key)HMAC-SHA384
$hmac.sha512(data, key)HMAC-SHA512
const signature = $hmac.sha256("important data", "my-secret-key");
const isValid = (signature === $hmac.sha256("important data", "my-secret-key")); // true

$crypto — Symmetrische versleuteling​

AES-GCM authenticated encryption (aanbevolen) en DES (verouderd, voor compatibiliteit).

MethodeGeeft terug
$crypto.encryptAES(plaintext, password, options?)Base64-ciphertext; bij fouten wordt een "Error: <reason>"-string teruggegeven.
$crypto.decryptAES(ciphertext, password, options?)Plaintext; ongeldige ciphertext geeft "Error: Invalid ciphertext" terug.
$crypto.encryptDES(plaintext, key)DES-ECB + PKCS7, key afgekapt tot 8 bytes → Base64.
$crypto.decryptDES(ciphertext, key)Plaintext; niet-Base64-invoer geeft "" terug.

options: { keySize: 128 \| 192 \| 256 } (standaard 256). Het AES-ciphertextformaat is base64(nonce[12] + ciphertext + tag[16]) — koppel het aan decryptAES; bij interoperabiliteit met andere talen moet je dit formaat zelf uitpakken.

const encrypted = $crypto.encryptAES("sensitive data", "my-password");
$crypto.decryptAES(encrypted, "my-password"); // "sensitive data"

// 128-bit key
const e128 = $crypto.encryptAES("data", "pass", { keySize: 128 });

// errors are returned as strings, not thrown — check the prefix
const out = $crypto.decryptAES("not-base64!!", "p");
if (out.startsWith("Error:")) { /* handle error */ }

$jwt — JSON Web Token​

Het maken, parsen en verifiëren van JWT-handtekeningen (HMAC-familie) voor authenticatiestromen in scripts.

MethodeGeeft terug
$jwt.sign(payload, secret, algorithm?)JWT-string; standaard HS256.
$jwt.decode(token){header, payload}-object (de handtekening wordt niet geverifieerd); geeft null terug bij misvormde tokens.
$jwt.verify(token, secret, algorithm?)boolean — het resultaat van de handtekeningverificatie.

algorithm: "HS256" | "HS384" | "HS512".

// sign
const payload = JSON.stringify({ sub: "user123", exp: Math.floor(Date.now() / 1000) + 3600 });
const token = $jwt.sign(payload, "my-secret", "HS256");

// decode — returns an object directly, no JSON.parse needed
const decoded = $jwt.decode(token);
decoded.header.alg; // "HS256"
decoded.payload.sub; // "user123"

// verify
$jwt.verify(token, "my-secret", "HS256"); // true
$jwt.verify(token, "wrong-secret", "HS256"); // false

// expiry check
const exp = $jwt.decode(token).payload.exp;
const expired = exp * 1000 < Date.now();

$format — Gegevensopmaak​

JSON/XML pretty-printing en minificatie voor logging en debugging. JSON-keys worden in de uitvoer alfabetisch gesorteerd.

MethodeGeeft terug
$format.json(str, indent?)Pretty-printed JSON; indent geklemd tot 1–8 (standaard 2); ongeldige invoer geeft "Error: Invalid JSON" terug.
$format.minify(str)Geminificeerde JSON (gesorteerde keys, geen witruimte); ongeldige invoer geeft "Error: Invalid JSON" terug.
$format.xml(str)Eenvoudig ingesprongen XML.
$format.json('{"b":1,"a":2}');
// {
// "a": 2,
// "b": 1
// }
$format.json('{"a":2}', 4); // 4-space indent
$format.minify('{ "a": 2 }'); // '{"a":2}'
$format.xml('<root><child>t</child></root>');
// <root>
// <child>t</child>
// </root>

$fs — Bestandssysteem​

Lichtgewicht lezen/schrijven van bestanden in scripts (configuratie, cache, export). Paden ondersteunen ~-expansie; write maakt ontbrekende bovenliggende mappen automatisch aan.

MethodeGeeft terug
$fs.read(path)UTF-8-inhoud; bij een fout "Error: Cannot read file at <path>".
$fs.readBinary(path)Bytes als Base64; bij een fout "".
$fs.write(path, content)boolean — succes.
$fs.exists(path)boolean.
$fs.delete(path)boolean; ontbrekende bestanden geven false terug.
$fs.list(path)string[] met mapitems; bij een fout [].
$fs.info(path)JSON-string {size, modified, isDirectory, path}; ontbrekende paden geven undefined terug.
const file = $env.tmpDir() + "/hodor-test.txt";
$fs.write(file, "Hello from Hodor!");
$fs.read(file); // "Hello from Hodor!"
$fs.exists(file); // true
$fs.list($env.tmpDir()); // ["hodor-test.txt", ...]

const info = JSON.parse($fs.info(file));
info.size; // byte count
info.isDirectory; // false

$fs.delete(file); // true
notitie

De foutvormen verschillen per methode: read geeft een "Error: ..."-string terug, readBinary geeft "" terug, list geeft [] terug en info geeft undefined terug — behandel elk daarvan passend.

$env — Omgevingsvariabelen​

Proces-omgevingsvariabelen en systeempaden. Let op: $env is de procesomgeving (gedeeld tussen uitvoeringen, leeft met het proces). Om gebruikersvariabelen te bewaren gebruik je sdk.setEnvVar of SharedPreferences.

MethodeGeeft terug
$env.get(key)Waarde; ontbrekende keys geven "" terug.
$env.set(key, value)boolean — het setenv-resultaat.
$env.all()JSON-string van alle omgevingsvariabelen.
$env.cwd()Huidige werkmap.
$env.tmpDir()Tijdelijke map.
$env.homeDir()Persoonlijke map van de gebruiker.
$env.set("APP_VERSION", "1.0.0");
$env.get("APP_VERSION"); // "1.0.0"
const all = JSON.parse($env.all());

$uuid — UUID​

UUID's genereren en valideren (verzoek-ID's, idempotentie-keys).

MethodeGeeft terug
$uuid.v4()Standaard v4-UUID (hoofdletters, met koppeltekens), bijv. "550e8400-E29B-41D4-A716-446655440000".
$uuid.compact()Vorm zonder koppeltekens, in kleine letters.
$uuid.validate(str)Of de string een geldige UUID is.
const id = $uuid.v4();
$uuid.compact(); // "550e8400e29b41d4a716446655440000"
$uuid.validate($uuid.v4()); // true
$uuid.validate("not-uuid"); // false
notitie

validate accepteert alleen het formaat met koppeltekens — validate($uuid.compact()) geeft false terug. Voeg koppeltekens opnieuw in voordat je een compacte string valideert.

$log — Gestructureerde logging​

Logregels met tijdstempel en niveau, gerouteerd via het consolesysteem van de engine (verzameld in de logweergave van het script).

MethodeGeeft terug
$log.log(level, message, tag?)Opgemaakte logregel (wordt ook afgedrukt).
$log.debug / info / warn / error(message)Handige niveaumethoden, alleen uitvoer.

Logregelformaat: [yyyy-MM-dd'T'HH:mm:ss.SSSZ] [LEVEL] [tag] message (het segment [tag] vervalt wanneer er geen tag is meegegeven).

$log.info("Server started on port 8080");
// [2025-07-24T01:11:45.548+0800] [INFO] Server started on port 8080
$log.log("info", "Request processed", "API");
// [2025-07-24T01:11:45.548+0800] [INFO] [API] Request processed

Web-API's​

fetch​

Verstuur echte HTTP-verzoeken vanuit scripts — het hoofdkanaal voor Postman-achtige workflows.

fetch(url: string, options?: object) → Promise<response>

options:

VeldTypeStandaardBeschrijving
methodstring"GET"Hoofdletterongevoelig; onbekende waarden vallen terug op GET.
timeoutIntervalnumber30Seconden.
headers[[k, v]] of [{k: v}][]Beide vormen worden geaccepteerd.
textBodystring—Tekst van de verzoek-body.
encodingstring—"hex" betekent dat textBody een hex-string is.

De opgeloste waarde is een plain object: statusCode (number), headers (array van objecten met één key, dubbele keys behouden) en textBody() — een functie die {text, encoding} teruggeeft met automatische tekensetdetectie (niet-decodeerbare bodies vallen terug op {text: <hex>, encoding: "hex"}). De verworpen waarde is een foutmelding als string.

// GET
const rsp = await fetch("https://httpbin.org/get");
if (rsp.statusCode === 200) {
const body = rsp.textBody(); // {text: "...", encoding: "utf-8"}
const json = JSON.parse(body.text);
}

// POST JSON
const rsp2 = await fetch("https://httpbin.org/post", {
method: "POST",
headers: [["Content-Type", "application/json"]],
textBody: JSON.stringify({a: 1}),
timeoutInterval: 10,
});

HTTPClient​

De klasse HTTPClient verstuurt HTTP-verzoeken vanuit elk script (geïmplementeerd bovenop fetch). Alle methoden zijn async en geven een antwoordobject terug met statusCode, headers en textBody().

MethodeBeschrijving
HTTPClient.get(url, params?)Verstuur een GET-verzoek.
HTTPClient.post(url, params?)Verstuur een POST-verzoek.
HTTPClient.put(url, params?)Verstuur een PUT-verzoek.
HTTPClient.update(url, params?)Verstuur een UPDATE-verzoek.
HTTPClient.delete(url, params?)Verstuur een DELETE-verzoek.
HTTPClient.request(url, method, params?)Verstuur een verzoek met een eigen methode.

params is een optioneel object met:

  • headers: object met verzoekheaders, bijv. {"key1": "value1"}
  • body: verzoek-body — een string, JSON-object (automatisch geserialiseerd) of URLSearchParams
  • timeoutInterval: time-out in seconden (standaard 60)
try {
var params = {
"headers": {"key1": "value1"},
"body": {"a": "a1", "b": "b1"},
};
const response = await HTTPClient.post("https://dummyjson.com/products/1", params);
console.log(response.textBody().text);
} catch(error) {
console.log(error);
}

Timers​

setTimeout / setInterval / clearTimeout / clearInterval werken zoals in browsers. Callbacks worden op een seriële engine-wachtrij afgehandeld, dus timers vuren betrouwbaar ongeacht de hostthread.

FunctieGeeft terug
setTimeout(callback, ms)Timer-id (string), vuurt één keer.
setInterval(callback, ms)Timer-id, vuurt herhaaldelijk.
clearTimeout(id) / clearInterval(id)Annuleren (idempotent, onbekende id's worden genegeerd).
await new Promise(resolve => setTimeout(resolve, 500)); // wait 0.5s
const timer = setInterval(() => console.log("tick"), 1000);
setTimeout(() => clearInterval(timer), 3500);

Globale functies​

NaamHandtekeningBeschrijving
btoa(str)(string) → stringBase64-encoding — UTF-8-symmetrische semantiek (niet-Latin1-strings zijn toegestaan, anders dan in browsers).
atob(str)(string) → stringBase64-decoding; ongeldige invoer geeft "" terug.
performance.now()() → numberMilliseconden sinds de epoch (niet pagina-load).
sleep(ms)(number) → PromiseLost op na ms; gebruik await sleep(1000).
require(id)(string) → anyLaad een scriptbibliotheek volgens CommonJS-semantiek (module.exports); de key is @libs/<key>, opgelost als scriptbibliotheek-identificator → scriptbibliotheeknaam (uniek) → ingebouwde bibliotheken; gooit een fout als niet gevonden.
TextEncodernew TextEncoder().encode(str)UTF-8-encoding naar een Uint8Array (encoding is altijd "utf-8").
crypto.getRandomValues(n)(Array) → number[]Vullen met n willekeurige UInt32-waarden.
crypto.randomUUID()() → stringWillekeurige UUID (hoofdletters, met koppeltekens).
btoa("Hello"); // "SGVsbG8="
atob("SGVsbG8="); // "Hello"
btoa("中文"); // works — UTF-8 bytes are encoded
performance.now(); // 1760000000000.123
await sleep(100);
const { encode } = require("@libs/base64"); // built-in lib
const { sign } = require("@libs/sign-lib"); // your script library
new TextEncoder().encode("hi"); // Uint8Array [104, 105]

Bibliotheken worden beheerd in de scriptmodulebeheerder. De require-key is altijd @libs/<key>: je eigen scriptbibliotheken worden eerst op identificator opgelost (stabiel bij hernoemen), daarna op naam (unieke match), en daarna de ingebouwde bibliotheken @libs/base64 / @libs/hex. Bibliotheken exporteren via module.exports, mogen andere bibliotheken laden, en een ontbrekende key gooit een fout (fouten vóór verzending breken het verzoek af, fouten na het antwoord behouden het oorspronkelijke antwoord). Zie Quick Request scripting, Scriptbibliotheken laden met require() voor de volledige handleiding.

console​

console.log / info / warn / error drukt waarden af in de logweergave van het script. Meerdere argumenten worden geserialiseerd, dus je kunt objecten en arrays direct loggen:

console.log("headers", {Accept: "application/json"}, [1, 2, 3]);

$log biedt gestructureerde uitvoer met niveaus (zie $log) — beide kanalen zijn zichtbaar in de scriptlogweergave van Hodor.

HTTP-klassen​

Request​

De klasse Request is het verpakte HTTP-verzoek dat aan onRequest / onSessionCompleted wordt doorgegeven.

MemberTypeBeschrijving
schemestring (get / set)Het scheme van het verzoek, bijv. https.
hoststring (get / set)De host van het verzoek.
portnumber (get / set)De poort van het verzoek.
pathstring (get / set)Het pad van het verzoek.
methodstring (get / set)De HTTP-methode, bijv. GET.
queriesURLSearchParams (get)De queryparameters van het verzoek.
headersHeaders (get)De headers van het verzoek.
bodyBody (get) / string | Map | Array | URLSearchParams (set)De body van het verzoek.
notitie

Headers moeten worden gewijzigd met .set() / .append() — indextoewijzing (bijv. headers["X-Key"] = v) wordt genegeerd.

Je kunt een verzoek ook zelf construeren:

const request = new Request({
scheme: 'https',
host: 'example.com',
port: 8080,
path: '/api',
method: 'GET',
queries: 'param1=value1&param2=value2',
headers: [
['Content-Type', 'application/json'],
['Authorization', 'Bearer token']
],
textBody: '{"key": "value"}'
});
console.log(request.encode());

Response​

De klasse Response vertegenwoordigt het HTTP-antwoord dat aan onResponse / onSessionCompleted wordt doorgegeven.

MemberTypeBeschrijving
statusCodenumber (get / set)De statuscode van het antwoord.
statusPhrasestring (get / set)De statusphrase van het antwoord, bijv. OK.
headersHeaders (get)De headers van het antwoord.
bodyBody (get) / string | Map | Array | URLSearchParams (set)De body van het antwoord.
const response = new Response({
statusCode: 404,
statusPhrase: 'Not Found',
headers: {
'Content-Type': 'application/json',
'Cache-Control': 'no-cache'
},
textBody: '{"error": "Resource not found"}'
});
console.log(response.encode());

Body​

De klasse Body vertegenwoordigt de body van een HTTP-verzoek of -antwoord. Het toewijzen van een nieuwe waarde aan request.body / response.body vervangt de hele body.

MethodeGeeft terugBeschrijving
parseText()string | nullParse de body als tekst.
parseJSON()object | nullParse de body als JSON.
parseURLSearchParams()URLSearchParams | nullParse de body als URL-gecodeerde parameters.
const bodyInstance = new Body('{"user": "alice"}');
const json = bodyInstance.parseJSON();
if (json) {
console.log('User:' + json.user);
} else {
console.error('Failed to parse JSON');
}

Headers​

De klasse Headers vertegenwoordigt HTTP-headers.

MethodeGeeft terugBeschrijving
append(name, value)voidVoeg een waarde toe aan de opgegeven header.
set(name, value)voidStel (vervang) de waarde van de opgegeven header in.
get(name)string | nullGeef de waarde van de opgegeven header terug.
has(name)booleanControleer of de opgegeven header bestaat.
delete(name)voidVerwijder de opgegeven header.
forEach(callback, thisArg?)voidRoep een functie aan voor elke header.
entries() / keys() / values()IteratorHerhaal over entries / keys / waarden.
encode()ArrayCodeer de headers naar een serialiseerbaar formaat.
const headers = new Headers();
headers.append('Content-Type', 'application/json');
headers.set('Content-Length', '1024');
console.log(headers.get('Content-Type')); // 'application/json'
console.log(headers.has('Authorization')); // false
headers.forEach((value, name) => {
console.log(name + ' ' + value);
});

URLSearchParams​

De klasse URLSearchParams vertegenwoordigt URL-queryparameters (of urlencoded body-parameters).

MethodeGeeft terugBeschrijving
append(name, value)voidVoeg een waarde toe aan de opgegeven parameter.
set(name, value)voidStel (vervang) de waarde van de opgegeven parameter in.
get(name)string | nullGeef de waarde van de opgegeven parameter terug.
has(name)booleanControleer of de opgegeven parameter bestaat.
delete(name)voidVerwijder de opgegeven parameter.
forEach(callback, thisArg?)voidRoep een functie aan voor elke parameter.
entries() / keys() / values()IteratorHerhaal over entries / keys / waarden.
sort()voidSorteer de parameters.
toString()stringSerialiseer naar een urlencoded string.
const params = new URLSearchParams({ key1: 'value1', key2: 'value2' });
console.log(params.get('key1')); // 'value1'
console.log(params.get('key3')); // null
params.forEach((value, key) => console.log(key + ' ' + value));

SharedPreferences​

De klasse SharedPreferences biedt lokale persistente key-value-opslag die scriptruns en app-herstarts overleeft (ondersteund door de system user defaults).

MethodeGeeft terugBeschrijving
SharedPreferences.write(key, value)voidSchrijf een waarde (string / number / boolean / object / array). Het schrijven van null verwijdert de key.
SharedPreferences.read(key)anyLees de waarde die bij de key hoort, of null als deze niet bestaat.
SharedPreferences.write("test_key", "test_value");
const value = SharedPreferences.read("test_key");
console.log(value);

SharedPreferences.write("cfg", {a: 1}); // objects are stored directly
SharedPreferences.write("cfg", null); // deletes "cfg"

sdk — Quick Request-scripts​

sdk (alias pm) wordt alleen geïnjecteerd in Quick Request pre/post-scripts. Het legt de brug naar de variabele-opslag van de app (omgevingen, globale en runtime-variabelen) en verzamelt asserties, met een Postman-achtige API-vorm.

MemberBeschrijving
sdk.env.get(key)Lees een omgevingsvariabele die in de app is gedefinieerd.
sdk.env.set(key, value)Stel een omgevingsvariabele in (zelfde als sdk.setEnvVar).
sdk.setEnvVar(key, value)Schrijf een env-variabele — wordt verzameld en teruggeschreven naar de app.
sdk.setVar(key, value)Schrijf een runtime-variabele (lokale variabele).
sdk.setGlobalVar(key, value)Schrijf een globale variabele.
sdk.getVar(key)Lees een runtime-variabele.
sdk.test(name, fn)Voer een benoemd assertieblok uit; fouten worden verzameld en in de app gerapporteerd.
sdk.expect(value)Assertie-primitieven: toBe, toEqual, toBeTruthy.
sdk.jsonPath(object, path)Dot-path-opzoeking, bijv. "$.data.list[0].id".
sdk.utils.uuid()Zelfde als crypto.randomUUID().
sdk.utils.base64Encode(s) / base64Decode(s)Zelfde als btoa / atob.
sdk.utils.md5(s)Zelfde als $hash.md5.
// Quick Request pre-request script: sign the request
async function onRequest(context, url, request) {
// read variables defined in the app's environment
const secret = sdk.env.get("secret") || "test-key";
sdk.expect(secret).toBeTruthy();

const ts = String(Date.now());
const bodyText = request.body && request.body.text ? request.body.text : '';
const sig = $hmac.sha256(ts + bodyText, secret);

// headers must be set via .set / .append
request.headers.set("X-Signature", sig);
request.headers.set("X-Timestamp", ts);

// persist variables back to the app
sdk.setEnvVar("lastTs", ts);
sdk.test("signature is 64 hex", () => {
sdk.expect(sig.length).toBe(64);
});

console.log("signed request for", url);
return request;
}
notitie

Assertieresultaten worden gerapporteerd voor pre-request-scripts. In scripts na het antwoord draaien asserties wel, maar de resultaten worden niet verzameld.

Contexten​

RewriteContext​

Het contextobject dat wordt doorgegeven aan rewrite-scripts (onRequest / onResponse).

MemberTypeBeschrijving
isEnableOnRequestboolean (get)Of de onRequest-entry is ingeschakeld.
isEnableOnResponseboolean (get)Of de onResponse-entry is ingeschakeld.
parametersobject (get / set)Een parameterwoordenboek dat wordt gedeeld tussen onRequest en onResponse.
scriptNamestring (get)De naam van het script.

CompletedContext​

Het contextobject dat wordt doorgegeven aan HTTP completed-scripts.

MemberTypeBeschrijving
sessionobject (get)Het sessieobject dat hoort bij het completed-script.
scriptNamestring (get)De naam van het completed-script.

ScheduleContext​

Het contextobject dat wordt doorgegeven aan schedule-scripts.

MemberTypeBeschrijving
parametersobject (get / set)Parameters die worden doorgegeven aan de volgende runloop wanneer ingesteld.
cronstring (get)De cron-expressie van de planning.
repeatedCountnumber (get)Hoe vaak het script is herhaald.
scriptNamestring (get)De naam van het geplande script.

Gedragsnotities​

  • Onafgevangen excepties laten het script falen. Fouten (waaronder AbortError van abort()) propageren naar Hodor en de uitvoering wordt als mislukt gerapporteerd — partiele herschrijvingen die vóór de fout zijn gemaakt worden weggegooid, omring dus risicovolle blokken met try / catch.
  • Time-out-watchdog. Elke scriptrun heeft een tijdsbudget; een script dat nooit afloopt (bijv. een eindloze lus of een vastgelopen await) wordt geforceerd onderbroken en als time-out gerapporteerd.
  • Fouten als teruggeefwaarden. Sommige API's gooien nooit: $codec.base64Decode geeft "" terug, $crypto geeft "Error: ..."-strings terug, $fs.read geeft "Error: ..."-strings terug en $fs.info geeft undefined terug. Controleer deze teruggeefwaarden in plaats van te vertrouwen op try / catch.
  • console.log versus $log. Beide zijn zichtbaar in de scriptlogweergave; $log voegt tijdstempels en niveaus toe.
  • Persistentie van de scriptruntime. Variabelen geschreven met sdk.setVar en bestanden geschreven met $fs blijven beschikbaar voor volgende uitvoeringen van hetzelfde script; SharedPreferences blijft behouden over app-herstarts heen.