,
hash: string,
}
```
**Syntaxe**
```
parseUrl(url);
```
**Exemple**
```
const parseUrl = require('parseUrl');const urlObject = parseUrl('https://abc:xyz@example.com:8080/foo?param=val%2Cue#bar');
```
**Paramètres**
| Paramètre | Type | Description |
| --------- | -------- | --------------------------------- |
| **`URL`** | *chaîne* | L'URL complète qui sera analysée. |
## `sha256`
Calcule le condensé SHA-256 de l'entrée et appelle un callback avec le condensé encodé en base64, sauf si l'objet `options` spécifie un encodage de sortie différent.
Cette signature d'API et ce comportement correspondent à l' [`sha256`](https://developers.google.com/tag-platform/tag-manager/templates/api#sha256) API pour les conteneurs web ; toutefois, les modèles personnalisés dans les conteneurs serveur devraient utiliser la [`sha256Sync`](https://developers.google.com/tag-platform/tag-manager/server-side/api#sha256sync) API pour un code plus simple.
**Syntaxe**
```
sha256(input, onSuccess, options = undefined);
```
**Exemple**
```
const encodeUriComponent = require('encodeUriComponent');const sendHttpGet = require('sendHttpGet');const sha256 = require('sha256');sha256('inputString', (digest) => { sendHttpGet('https://example.com/collect?id=' + encodeUriComponent(digest));});sha256('inputString', (digest) => { sendHttpGet('https://example.com/collect?id=' + encodeUriComponent(digest));}, {outputEncoding: 'hex'});
```
**Paramètres**
| Paramètre | Type | Description |
| --------------- | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`input`** | *chaîne* | La chaîne à hacher. |
| **`onSuccess`** | *fonction* | Appelé avec le condensé résultant, encodé en base64, sauf si le `options` spécifie un encodage de sortie différent. |
| **`options`** | *objet* | *Facultatif* objet d'options permettant de personnaliser l'encodage de sortie. S'il est spécifié, l'objet doit contenir la clé `outputEncoding` avec comme valeur l'une de `base64` ou `hex`. |
## `sha256Sync`
Calcule et renvoie le condensé SHA-256 de l'entrée, encodé en base64, sauf si le `options` spécifie un encodage de sortie différent.
**Syntaxe**
```
sha256Sync(input, options = undefined);
```
**Exemple**
```
const encodeUriComponent = require('encodeUriComponent');const sendHttpGet = require('sendHttpGet');const sha256Sync = require('sha256Sync');const digestBase64 = sha256Sync('inputString');const digestHex = sha256Sync('inputString', {outputEncoding: 'hex'});sendHttpGet('https://example.com/collect?id=' + encodeUriComponent(digestBase64));sendHttpGet('https://example.com/collect?id=' + encodeUriComponent(digestHex));
```
**Paramètres**
| Paramètre | Type | Description |
| ------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`input`** | *chaîne* | La chaîne à hacher. |
| **`options`** | *objet* | *Facultatif* objet d'options permettant de personnaliser l'encodage de sortie. S'il est spécifié, l'objet doit contenir la clé `outputEncoding` avec comme valeur l'une de `base64` ou `hex`. |
## `signHmac`
Génère une signature HMAC pour le payload donné, en utilisant `sha256` et `base64` l'encodage par défaut, sauf si le `options` objet spécifie autre chose. Les objets passés en tant que payload sont automatiquement `JSON.stringify`'és. Renvoie un **chaîne**.
**Syntaxe**
```javascript
signHmac(payload, secret, options = undefined);
```
**Exemple**
```javascript
const signHmac = require('signHmac');
// Signe une chaîne avec les options par défaut (sha256 + base64)
const signature = signHmac('my payload', 'mySecretKey');
// Signature avec un algorithme et un encodage personnalisés
const signatureHex = signHmac('my payload', 'mySecretKey', { alg: 'sha1', outputEncoding: 'hex' });
// Signe un objet (automatiquement JSON.stringify'ê)
const objectSignature = signHmac({ key: 'value' }, 'mySecretKey');
```
**Paramètres**
| Paramètre | Type | Description |
| ------------- | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| **`payload`** | *string\|object* | Les données à signer. Les objets sont automatiquement convertis en chaînes JSON. |
| **`secret`** | *chaîne* | La clé secrète utilisée pour la génération HMAC. |
| **`options`** | *objet* | *Facultatif* Objet d'options permettant de personnaliser l'algorithme et l'encodage de sortie. Voir les détails des options ci-dessous. |
**Options**
| Propriété | Type | Valeur par défaut | Description |
| -------------------- | -------- | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`alg`** | *chaîne* | `'sha256'` | L'algorithme de hachage. Valeurs prises en charge : `'sha256'`, `'sha1'`, `'sha512'`, `'sha384'`, `'md5'` et d'autres algorithmes de digest OpenSSL. |
| **`outputEncoding`** | *chaîne* | `'base64'` | L'encodage de sortie. Valeurs prises en charge : `'base64'`, `'base64url'`, `'hex'`, `'binary'` (`latin1`). |
## `toBase64`
Encode une chaîne en base64.
**Syntaxe**
```
toBase64(input);
```
**Exemple**
```
const toBase64 = require('toBase64');const base64Hello = toBase64('hello');
```
**Paramètres**
| Paramètre | Type | Description |
| ----------- | -------- | ----------------- |
| **`input`** | *chaîne* | Chaîne à encoder. |
## `JSON`
Renvoie un objet qui fournit des fonctions JSON.
Le `parse()` La fonction parse analyse une chaîne JSON pour construire la valeur ou l'objet décrit par la chaîne. Si la valeur ne peut pas être analysée (JSON mal formé), la fonction renverra `undefined`. Si la valeur d'entrée n'est pas une chaîne, l'entrée sera convertie en chaîne.
Le `stringify()` La fonction convertit l'entrée en une chaîne JSON. Si la valeur ne peut pas être analysée (par ex. l'objet contient un cycle), la méthode renverra `undefined`.
**Syntaxe**
```
JSON.parse(yourString);
JSON.stringify(yourObject);
```
**Exemple**
```
const JSON = require('JSON');
// La chaîne JSON d'entrée est convertie en objet.
const object = JSON.parse('{"foo":"bar"}');
// L'objet d'entrée est converti en chaîne JSON.
const str = JSON.stringify({foo: 'bar'});
```
***
## `Math`
Un objet fournissant `Math` des fonctions.
**Syntaxe**
```
const Math = require('Math');
// Récupère la valeur absolue.
const absolute = Math.abs(-5);
// Arrondit l'entrée à l'entier inférieur le plus proche.
const roundedDown = Math.floor(4.6);
// Arrondit l'entrée à l'entier supérieur le plus proche.
const roundedUp = Math.ceil(2.1);
// Arrondit l'entrée à l'entier le plus proche.
const rounded = Math.round(4.2);
// Renvoie l'argument le plus grand.
const biggest = Math.max(1, 4);
// Renvoie l'argument le plus petit.
const smallest = Math.min(4, 5);
// Renvoie le premier argument élevé à la puissance du deuxième argument.
const powerful = Math.pow(4, 2);
// Renvoie la racine carrée de l'argument.
const unsquared = Math.sqrt(81);
```
**Paramètres**
Les paramètres des fonctions Math sont convertis en nombres.
## `sendHttpGet`
Effectue une requête HTTP GET vers l'URL spécifiée et appelle un callback avec la réponse une fois la requête terminée ou en timeout.
**Syntaxe**
```javascript
sendHttpGet(url[, callback[, options]]);
```
**Exemple**
```javascript
const sendHttpGet = require('sendHttpGet');
// Envoie une requête GET et sélectionne la réponse// en fonction de la réponse du GET
sendHttpGet('https://example.com/collect', function(statusCode, headers, body) {
if (statusCode != 200) {yourCallbackFunction();}
}, {
headers: {key: 'value'},
timeout: 500
});
```
**Paramètres**
| Paramètre | Type | Description |
| -------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`URL`** | *chaîne* | L'URL de la requête. |
| **`callback`** | *fonction* | Un callback facultatif à invoquer à la fin de la requête, en cas d'erreur ou de timeout.
Il est invoqué avec le code d'état de réponse, le en-têtes de réponse, et le corps de réponse (ou undefined s'il n'y avait pas de corps de réponse).
Si la requête a échoué (par ex. URL invalide, aucune route vers l'hôte, échec de négociation SSL, etc.), le callback sera invoqué avec un code d'état de réponse égal à zéro, aucun en-tête, et un corps undefined.
Si le 'timeout' l’option a été définie et la requête a expiré, le callback sera invoqué avec un code d’état de réponse de -1, aucun en-tête, et un corps undefined.
|
| **`options`** | *objet* | Options de requête facultatives. Les options prises en charge sont **headers**, **timeout**. Des options avancées peuvent être ajoutées dans **extraOptions** |
#### **Options**
* **headers**: En-têtes supplémentaires de la requête représentés sous forme d'objet.
* **timeout**: Le délai d'attente, en millisecondes, avant l'abandon de la requête.
* **extraOptions**: Options avancées (ex. : {strictSSL:true})
## `sendHttpRequest`
Effectue une requête HTTP vers l'URL spécifiée et invoque un callback avec la réponse une fois la requête terminée ou expirée.
**Syntaxe**
```
sendHttpRequest(url[, callback[, options[, body]]]);
```
**Exemple**
```javascript
const sendHttpRequest = require('sendHttpRequest');
const body = {
user_type:'vip',
account:'123'
};
// Envoie une requête POST
sendHttpRequest('https://example.com/collect', function(statusCode, headers, body) {
// votre code de callback...
}, {
headers: {
token: '123456789'
},
method: 'POST',
timeout: 1000
}, JSON.stringify(body));
```
**Paramètres**
| Paramètre | Type | Description |
| -------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`URL`** | *chaîne* | L'URL de la requête. |
| **`callback`** | *fonction* | Un callback facultatif à invoquer à la fin de la requête, en cas d'erreur ou de timeout.
Il est invoqué avec le code d'état de réponse, le en-têtes de réponse, et le corps de réponse (ou undefined s'il n'y avait pas de corps de réponse).
Si la requête a échoué (par ex. URL invalide, aucune route vers l'hôte, échec de négociation SSL, etc.), le callback sera invoqué avec un code d'état de réponse égal à zéro, aucun en-tête, et un corps undefined.
Si l'option 'timeout' a été définie et que la requête a expiré, le callback sera invoqué avec un code d’état de réponse de -1, aucun en-tête, et un corps undefined.
|
| **`options`** | *objet* | Options de requête facultatives. Les options prises en charge sont : **headers**, **méthode**, et **timeout**. Les clés d'option inconnues sont ignorées. Des options avancées peuvent être ajoutées dans **extraOptions.** |
| **`body`** | *chaîne* | Corps de requête facultatif. |
**Options**
* **headers**: En-têtes supplémentaires de la requête.
* **méthode**: La méthode de requête, par défaut 'GET'.
* **timeout**: Le délai d'attente, en millisecondes, avant l'abandon de la requête.
* **extraOptions**: Options avancées (ex. : {strictSSL:true})
## `md5Sync`
Calcule et renvoie le `md5` condensé de l'entrée.
**Syntaxe**
```
md5Sync(input);
```
**Exemple**
```javascript
const md5Sync= require('md5Sync');
const email = {};
email.md5 = md5Sync(user.user_email);
sendHttpGet('https://example.com/collect?e5=' + email.md5);
```
## `templateDataStorage`
Le `templateDataStorage` ce helper permet le stockage et la récupération temporaires de données, telles que des API tokens, pendant l'exécution du script. Il est particulièrement utile pour mettre en cache des données réutilisables afin de réduire les appels API redondants. Les données stockées dans `templateDataStorage` persistent sur le serveur exécutant le template. Comme les templates s'exécutent sur plusieurs serveurs, et que chaque serveur peut avoir plusieurs instances, il n'est pas garanti que les données stockées soient accessibles pour toutes les exécutions ultérieures du template.
**Syntaxe**
```javascript
templateDataStorage.setItemCopy(key, value);
templateDataStorage.getItemCopy(key);
templateDataStorage.removeItemCopy(key);
```
**Exemple : gestion des API tokens**
```javascript
const sendHttpRequest = require('sendHttpRequest');
const templateDataStorage = require('templateDataStorage');
const tokenKey = 'apiToken';
function fetchNewToken(callback) {
sendHttpRequest('https://example.com/api/token', function (status, _, body) {
if (status === 200) {
const { accessToken, expiresIn } = JSON.parse(body);
const tokenData = { token: accessToken, expiry: Date.now() + expiresIn * 1000 };
templateDataStorage.setItemCopy(tokenKey, tokenData);
callback(accessToken);
} else {
callback(null);
}
}, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ clientId: 'id', clientSecret: 'secret' }) });
}
function sendEvent(eventData) {
const cachedToken = templateDataStorage.getItemCopy(tokenKey);
const token = cachedToken && cachedToken.expiry > Date.now() ? cachedToken.token : null;
sendHttpRequest('https://example.com/api/events', function (status) {
if (status === 401) {
fetchNewToken(function (newToken) {
if (newToken) {
sendHttpRequest('https://example.com/api/events', () => {}, { method: 'POST', headers: { Authorization: `Bearer ${newToken}` }, body: JSON.stringify(eventData) });
}
});
}
}, { method: 'POST', headers: { Authorization: `Bearer ${token}` }, body: JSON.stringify(eventData) });
}
sendEvent({ eventName: 'purchase', value: 100 });
```
| Méthode | Description |
| ----------------------------- | ------------------------------------------------------------------------------------------- |
| **`setItemCopy(key, value)`** | Stocke une valeur sous la clé spécifiée. Écrase la valeur si la clé existe déjà. |
| **`getItemCopy(key)`** | Récupère la valeur associée à la clé spécifiée. Renvoie `undefined` si la clé n'existe pas. |
| **`removeItemCopy(key)`** | Supprime la valeur associée à la clé spécifiée. |
| Paramètre | Type | Description |
| ----------- | -------- | ----------------------------------------------------- |
| **`clé`** | *chaîne* | L'identifiant unique des données à stocker/récupérer. |
| **`value`** | *any* | Les données à stocker (pour `setItemCopy`). |
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://doc.commandersact.com/fr/fonctionnalites/destinations/destination-builder/javascript-destination-builder/serverside-js-helpers.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.