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:
| Categorie | Namen |
|---|---|
| Entryfuncties | onRequest, onResponse, onSessionCompleted, onSchedule, abort() |
Native $-modules | $codec, $hash, $hmac, $crypto, $jwt, $format, $fs, $env, $uuid, $log |
| Web-standaard-API's | fetch, HTTPClient, setTimeout / setInterval, btoa / atob / sleep / require / TextEncoder / crypto, console |
| HTTP-klassen | Request, Response, Body, Headers, URLSearchParams |
| Opslag | SharedPreferences, sdk-variabelen |
| Contexten | RewriteContext, CompletedContext, ScheduleContext |
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.
| Parameter | Type | Beschrijving |
|---|---|---|
context | RewriteContext | Het contextobject. |
url | string | De URL van het HTTP-verzoek. |
request | Request | Het 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.
| Parameter | Type | Beschrijving |
|---|---|---|
context | RewriteContext | Het contextobject. |
url | string | De URL van het HTTP-antwoord. |
response | Response | Het 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.
| Parameter | Type | Beschrijving |
|---|---|---|
context | CompletedContext | Het contextobject. |
url | string | De URL van het HTTP-verzoek. |
request | Request | Het HTTP-verzoekobject. |
response | Response | Het 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.
| Parameter | Type | Beschrijving |
|---|---|---|
context | ScheduleContext | Het 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;
}
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.
| Methode | Geeft 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.
| Methode | Uitvoerlengte |
|---|---|
$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.
| Methode | Algoritme |
|---|---|
$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).
| Methode | Geeft 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.
| Methode | Geeft 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.
| Methode | Geeft 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.
| Methode | Geeft 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
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.
| Methode | Geeft 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).
| Methode | Geeft 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
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).
| Methode | Geeft 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:
| Veld | Type | Standaard | Beschrijving |
|---|---|---|---|
method | string | "GET" | Hoofdletterongevoelig; onbekende waarden vallen terug op GET. |
timeoutInterval | number | 30 | Seconden. |
headers | [[k, v]] of [{k: v}] | [] | Beide vormen worden geaccepteerd. |
textBody | string | — | Tekst van de verzoek-body. |
encoding | string | — | "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().
| Methode | Beschrijving |
|---|---|
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 URLSearchParamstimeoutInterval: 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.
| Functie | Geeft 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
| Naam | Handtekening | Beschrijving |
|---|---|---|
btoa(str) | (string) → string | Base64-encoding — UTF-8-symmetrische semantiek (niet-Latin1-strings zijn toegestaan, anders dan in browsers). |
atob(str) | (string) → string | Base64-decoding; ongeldige invoer geeft "" terug. |
performance.now() | () → number | Milliseconden sinds de epoch (niet pagina-load). |
sleep(ms) | (number) → Promise | Lost op na ms; gebruik await sleep(1000). |
require(id) | (string) → any | Laad 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. |
TextEncoder | new 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() | () → string | Willekeurige 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.
| Member | Type | Beschrijving |
|---|---|---|
scheme | string (get / set) | Het scheme van het verzoek, bijv. https. |
host | string (get / set) | De host van het verzoek. |
port | number (get / set) | De poort van het verzoek. |
path | string (get / set) | Het pad van het verzoek. |
method | string (get / set) | De HTTP-methode, bijv. GET. |
queries | URLSearchParams (get) | De queryparameters van het verzoek. |
headers | Headers (get) | De headers van het verzoek. |
body | Body (get) / string | Map | Array | URLSearchParams (set) | De body van het verzoek. |
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¶m2=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.
| Member | Type | Beschrijving |
|---|---|---|
statusCode | number (get / set) | De statuscode van het antwoord. |
statusPhrase | string (get / set) | De statusphrase van het antwoord, bijv. OK. |
headers | Headers (get) | De headers van het antwoord. |
body | Body (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.
| Methode | Geeft terug | Beschrijving |
|---|---|---|
parseText() | string | null | Parse de body als tekst. |
parseJSON() | object | null | Parse de body als JSON. |
parseURLSearchParams() | URLSearchParams | null | Parse 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.
| Methode | Geeft terug | Beschrijving |
|---|---|---|
append(name, value) | void | Voeg een waarde toe aan de opgegeven header. |
set(name, value) | void | Stel (vervang) de waarde van de opgegeven header in. |
get(name) | string | null | Geef de waarde van de opgegeven header terug. |
has(name) | boolean | Controleer of de opgegeven header bestaat. |
delete(name) | void | Verwijder de opgegeven header. |
forEach(callback, thisArg?) | void | Roep een functie aan voor elke header. |
entries() / keys() / values() | Iterator | Herhaal over entries / keys / waarden. |
encode() | Array | Codeer 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).
| Methode | Geeft terug | Beschrijving |
|---|---|---|
append(name, value) | void | Voeg een waarde toe aan de opgegeven parameter. |
set(name, value) | void | Stel (vervang) de waarde van de opgegeven parameter in. |
get(name) | string | null | Geef de waarde van de opgegeven parameter terug. |
has(name) | boolean | Controleer of de opgegeven parameter bestaat. |
delete(name) | void | Verwijder de opgegeven parameter. |
forEach(callback, thisArg?) | void | Roep een functie aan voor elke parameter. |
entries() / keys() / values() | Iterator | Herhaal over entries / keys / waarden. |
sort() | void | Sorteer de parameters. |
toString() | string | Serialiseer 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).
| Methode | Geeft terug | Beschrijving |
|---|---|---|
SharedPreferences.write(key, value) | void | Schrijf een waarde (string / number / boolean / object / array). Het schrijven van null verwijdert de key. |
SharedPreferences.read(key) | any | Lees 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.
| Member | Beschrijving |
|---|---|
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;
}
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).
| Member | Type | Beschrijving |
|---|---|---|
isEnableOnRequest | boolean (get) | Of de onRequest-entry is ingeschakeld. |
isEnableOnResponse | boolean (get) | Of de onResponse-entry is ingeschakeld. |
parameters | object (get / set) | Een parameterwoordenboek dat wordt gedeeld tussen onRequest en onResponse. |
scriptName | string (get) | De naam van het script. |
CompletedContext
Het contextobject dat wordt doorgegeven aan HTTP completed-scripts.
| Member | Type | Beschrijving |
|---|---|---|
session | object (get) | Het sessieobject dat hoort bij het completed-script. |
scriptName | string (get) | De naam van het completed-script. |
ScheduleContext
Het contextobject dat wordt doorgegeven aan schedule-scripts.
| Member | Type | Beschrijving |
|---|---|---|
parameters | object (get / set) | Parameters die worden doorgegeven aan de volgende runloop wanneer ingesteld. |
cron | string (get) | De cron-expressie van de planning. |
repeatedCount | number (get) | Hoe vaak het script is herhaald. |
scriptName | string (get) | De naam van het geplande script. |
Gedragsnotities
- Onafgevangen excepties laten het script falen. Fouten (waaronder
AbortErrorvanabort()) 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 mettry / 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.base64Decodegeeft""terug,$cryptogeeft"Error: ..."-strings terug,$fs.readgeeft"Error: ..."-strings terug en$fs.infogeeftundefinedterug. Controleer deze teruggeefwaarden in plaats van te vertrouwen optry / catch. console.logversus$log. Beide zijn zichtbaar in de scriptlogweergave;$logvoegt tijdstempels en niveaus toe.- Persistentie van de scriptruntime. Variabelen geschreven met
sdk.setVaren bestanden geschreven met$fsblijven beschikbaar voor volgende uitvoeringen van hetzelfde script;SharedPreferencesblijft behouden over app-herstarts heen.