Scripts dans le générateur de modèles

Votre script                    Le moteur                      Résultat
    |                              |                              |
    v                              v                              v
documents.get("article", "intro") --> Récupère depuis la base de données --> { headline: "Welcome", body: "..." }
         .headline                --> Extrait le champ        --> "Welcome"

// Accéder au champ price du document courant
doc.price

// Calculer un total à partir des champs du document courant
doc.price * doc.quantity

// Condition en fonction de l'état du document courant
doc.status == "published" ? doc.title : "Brouillon : " + doc.title

// Stocké dans le CMS sous : article / welcome-post
{
  "headline": "Bienvenue sur notre plateforme",
  "author": "Sarah Chen",
  "body": "Nous sommes ravis d'annoncer...",
  "tags": ["annonce", "actualités"]
}

documents.get("article", "welcome-post")

{
  "headline": "Bienvenue sur notre plateforme",
  "author": "Sarah Chen",
  "body": "Nous sommes ravis d'annoncer...",
  "tags": ["annonce", "actualités"]
}

documents.get("article", "welcome-post").headline

documents.get("article", "welcome-post").author

documents.get("article", meta.params.slug).headline

// Obtenir tous les pays
documents.find("country")

[
  { "code": "us", "name": "États-Unis", "flag": "US" },
  { "code": "sa", "name": "Arabie saoudite", "flag": "SA" },
  { "code": "gb", "name": "Royaume-Uni", "flag": "GB" }
]

// Obtenir des pays avec un filtre
documents.find("country", { "where": { "code": "us" } })

[
  { "code": "us", "name": "États-Unis", "flag": "US" }
]

// Si meta.locale vaut "fr", renvoie la traduction française fusionnée avec le document de base
documents.get("greeting", "welcome").headline

// Toujours récupérer la traduction espagnole
documents.translated("greeting", "welcome", "es").headline

// Récupérer la traduction en fonction du paramètre d'URL
documents.translated("product", meta.params.id, meta.params.lang).description

// Comparer des traductions
documents.translated("article", "intro", "en").title + " / " + documents.translated("article", "intro", "fr").title

// Document de base : greeting / welcome
{ "headline": "Welcome", "subheadline": "Welcome to our platform" }

// Traduction (langue : "fr")
{ "headline": "Bienvenue", "subheadline": "Bienvenue sur notre plateforme" }

// Traduction (langue : "es")
{ "headline": "Bienvenido", "subheadline": "Bienvenido a nuestra plataforma" }

// Avec meta.locale = "fr"
documents.get("greeting", "welcome").headline
// Renvoie : "Bienvenue"

// Traduction espagnole explicite
documents.translated("greeting", "welcome", "es").headline
// Renvoie : "Bienvenido"

// Patrons de repli en cas de traduction manquante
documents.translated("greeting", "welcome", meta.params.lang) != null
  ? documents.translated("greeting", "welcome", meta.params.lang).headline
  : documents.get("greeting", "welcome").headline

{
  "headline": "Construisez plus vite, livrez plus intelligemment",
  "subheadline": "Le CMS moderne pour les développeurs"
}

documents.get("article", "homepage-hero").headline

// country / us
{ "code": "us", "name": "États-Unis", "flag": "US", "languages": ["en", "es"] }

// country / sa
{ "code": "sa", "name": "Arabie saoudite", "flag": "SA", "languages": ["ar", "en"] }

documents.get("country", meta.params.code).name

meta.locale == "ar-SA" ? "Bienvenue à tous" : "Bienvenue"

{ "headline": "Actualités des États-Unis", "countryCode": "us" }

documents.get("country", documents.get("article", "us-news").countryCode).name

documents.get("article", meta.params.slug) != null
  ? documents.get("article", meta.params.slug).headline
  : "Article introuvable"

documents.get("article", "intro").author != null
  ? documents.get("article", "intro").author
  : "Auteur inconnu"

"featured" in documents.get("article", "welcome-post").tags

documents.get("article", "welcome-post").tags[0]

size(documents.get("article", "welcome-post").tags)

{
  "pattern": "/{lang}/landingPage",
  "param_bindings": {
    "lang": "language"
  }
}

// greeting / ko
{ "code": "ko", "headline": "Welcome", "subheadline": "Welcome to our platform", "ctaText": "Get Started", "ctaUrl": "/ko/get-started" }

// greeting / en
{ "code": "en", "headline": "Welcome", "subheadline": "Welcome to our platform", "ctaText": "Get Started", "ctaUrl": "/en/get-started" }

// greeting / ja
{ "code": "ja", "headline": "Welcome", "subheadline": "Welcome to our platform", "ctaText": "Start", "ctaUrl": "/ja/get-started" }

documents.get("greeting", meta.params.lang).headline

{
  "pattern": "/{country}/{lang}/products",
  "param_bindings": {
    "country": "country",
    "lang": "language"
  }
}

// Obtenir le nom du pays
documents.get("country", meta.params.country).name

// Obtenir la liste des produits localisée selon le pays
documents.find("product", { "where": { "country": meta.params.country } })

// Combiné : afficher une salutation spécifique au pays dans la langue de l'utilisateur
documents.get("greeting", meta.params.lang).headline + " depuis " + documents.get("country", meta.params.country).name

// Obtenir le premier segment (souvent le code langue)
meta.segments[0]

// Vérifier la profondeur du chemin
size(meta.segments) > 2 ? "profond" : "peu profond"

// Vérifier si nous sommes dans la section admin
"admin" in meta.segments ? "mode admin" : "mode public"

// Repli : utiliser le segment si le paramètre n'est pas lié
has(meta.params.lang) ? meta.params.lang : meta.segments[0]

// Vérifier la locale pour les langues RTL
meta.locale == "ar-SA" || meta.locale == "he-IL" ? "rtl" : "ltr"

// Obtenir uniquement la partie langue
meta.locale.split("-")[0]  // Non pris en charge - utilisez plutôt meta.params.lang

// Accéder à un paramètre nommé
meta.params.lang           // "ko"
meta.params.country        // "us"
meta.params.slug           // "welcome-post"

// Vérifier si un paramètre existe
has(meta.params.category)  // true/false

// Utiliser lors d'une récupération de document
documents.get("greeting", meta.params.lang)
documents.ref("airports").get(meta.params.code)

// Accéder par index (à partir de 0)
meta.segments[0]           // Premier segment
meta.segments[1]           // Deuxième segment

// Vérifier la longueur
size(meta.segments)        // Nombre de segments

// Vérifier la présence
"products" in meta.segments  // Le chemin contient-il "products" ?

// Disponible uniquement lors de l'édition d'un document existant
meta.docId != null ? "édition" : "création"

// Utiliser dans une logique conditionnelle
meta.docId != null ? documents.get("article", meta.docId).status : "draft"

// Utiliser pour l'affichage
"Édition : " + meta.title

// Condition basé sur le titre
meta.title.contains("Draft") ? "travail en cours" : "publié"

// Approche traditionnelle
documents.get("airports", meta.params.code).name

// Avec ref() - schéma séparé de l'identifiant dynamique
documents.ref("airports").get(meta.params.code).name

documents.get("schema", "identifier")       // Récupérer un document
documents.get("schema", "id").fieldName     // Récupérer un champ spécifique
documents.find("schema")                    // Récupérer tous les documents
documents.find("schema", { "where": {...}}) // Requête filtrée
documents.ref("schema").get(identifier)     // Recherche chaînée
documents.translated("schema", "id", "fr")  // Récupération avec locale explicite

meta.locale          // "en-US", "ar-SA", etc.
meta.params.xyz      // Paramètre d'URL nommé "xyz"
meta.segments        // Chemin d'URL sous forme de tableau : ["articles", "intro"]
meta.segments[0]     // Premier segment du chemin
meta.docId           // ID du document courant (ou null)
meta.title           // Titre du document courant
doc.fieldName        // Valeur du champ du document courant (en contexte éditeur)

// Comparaison
==  !=  <  <=  >  >=

// Logique
&&  ||  !

// Ternaires (if-else)
condition ? valeurSiVrai : valeurSiFaux

// Appartenance
"value" in listOrMap

size(list)                    // Compter les éléments
size(string)                  // Longueur d'une chaîne
"text".startsWith("te")       // true
"text".endsWith("xt")         // true
"text".contains("ex")         // true
has(object.property)          // Vérifier si la propriété existe
hasProperty(obj, "key")       // Vérifier si l'objet possède la clé (syntaxe alternative)

// Futur : appeler des services externes via MCP
mcp.translate(meta.params.text, "en", meta.params.lang)
mcp.analyze(documents.get("article", meta.params.id).body)

// Futur : génération de contenu assistée par IA
ai.summarize(documents.get("article", meta.params.id).body, 100)
ai.translate(meta.params.text, meta.params.targetLang)
ai.classify(meta.params.input, ["positive", "negative", "neutral"])

// L'article stocke l'ID de l'auteur, récupérer le nom de l'auteur
documents.get("author", documents.get("article", "intro").authorId).name

// Approche traditionnelle
documents.get("country", documents.get("airport", meta.params.code).countryCode).name

// Avec ref() - plus clair lorsque le schéma est connu mais l'identifiant est dynamique
documents.ref("country").get(documents.get("airport", meta.params.code).countryCode).name

// Aéroport → Pays → Région → Continent
documents.get("continent",
  documents.get("region",
    documents.get("country",
      documents.get("airport", meta.params.code).countryCode
    ).regionCode
  ).continentCode
).name

// Obtenir le nom localisé du pays pour un aéroport
documents.translated("country",
  documents.get("airport", meta.params.code).countryCode,
  meta.params.lang
).name

// article / tech-news
{ "title": "Mise à jour tech", "authorId": "author-123", "categoryId": "cat-tech" }

// Résoudre le nom de l'auteur
documents.get("author", documents.get("article", meta.params.slug).authorId).name

// Résoudre la catégorie avec repli
documents.get("article", meta.params.slug).categoryId != null
  ? documents.get("category", documents.get("article", meta.params.slug).categoryId).name
  : "Sans catégorie"

// airport / JFK
{ "code": "JFK", "name": "John F. Kennedy International", "countryCode": "us" }

// country / us
{ "code": "us", "name": "États-Unis", "currencyCode": "usd" }

// currency / usd
{ "code": "usd", "symbol": "$", "name": "Dollar américain" }

// Chaîne Aéroport → Pays → Devise
documents.get("currency",
  documents.get("country",
    documents.get("airport", meta.params.code).countryCode
  ).currencyCode
).symbol
// Pour JFK : renvoie "$"

// Dans un document produit, récupérer les détails de la catégorie liée
documents.get("category", doc.categoryId).description

// Coût d'expédition calculé d'après le pays d'origine du produit
documents.get("shipping-rates", doc.originCountry).baseRate * doc.weight

// Récupérer l'auteur de l'article, puis les autres articles de cet auteur (surveillez le nombre de fetch)
documents.find("article", { "where": { "authorId": documents.get("article", meta.params.slug).authorId } })

// content-block / hero-1
{ "type": "hero", "sourceType": "article", "sourceId": "welcome-post" }

// content-block / hero-2
{ "type": "hero", "sourceType": "product", "sourceId": "featured-item" }

// Recherche de schéma dynamique selon sourceType
documents.get("content-block", "hero-1").sourceType == "article"
  ? documents.get("article", documents.get("content-block", "hero-1").sourceId).headline
  : documents.get("product", documents.get("content-block", "hero-1").sourceId).name

// Mauvais : récupère le même document deux fois
documents.get("author", documents.get("article", "intro").authorId).name + " - " +
documents.get("author", documents.get("article", "intro").authorId).bio

// Mieux : utilisez une condition pour vérifier une seule fois
documents.get("article", "intro").authorId != null
  ? documents.get("author", documents.get("article", "intro").authorId).name
  : "Auteur inconnu"

{
  "name": "greeting",
  "fields": [
    { "name": "code", "type": "string", "required": true },
    { "name": "headline", "type": "string", "required": true },
    { "name": "subheadline", "type": "string" },
    { "name": "ctaText", "type": "string" },
    { "name": "ctaUrl", "type": "string" }
  ]
}

{
  "code": "ko",
  "headline": "Welcome",
  "subheadline": "Welcome to our platform",
  "ctaText": "Get Started",
  "ctaUrl": "/ko/get-started"
}

{
  "code": "en",
  "headline": "Welcome",
  "subheadline": "Welcome to our platform",
  "ctaText": "Get Started",
  "ctaUrl": "/en/get-started"
}

{
  "code": "ja",
  "headline": "Welcome",
  "subheadline": "Welcome to our platform",
  "ctaText": "Start",
  "ctaUrl": "/ja/get-started"
}

  {
    "lang": "language"
  }

documents.get("greeting", meta.params.lang).headline

documents.get("greeting", meta.params.lang).subheadline

documents.get("greeting", meta.params.lang).ctaText

documents.get("greeting", meta.params.lang).ctaUrl

// app/[...slug]/page.tsx
import ParametricRoutePage from 'cms-renderer/lib/renderer';
import { registry } from '@/lib/registry';
import { cmsConfig } from '@/lib/cms-config';

export const dynamic = 'force-static';

interface PageProps {
  params: Promise<{ slug: string[] }>;
}

export default async function Page({ params }: PageProps) {
  const { slug } = await params;

  return (
    <ParametricRoutePage
      registry={registry}
      apiKey={cmsConfig.apiKey}
      websiteId={cmsConfig.websiteId}
      cmsUrl={cmsConfig.cmsUrl}
      params={Promise.resolve({ slug })}
    />
  );
}

interface CelMeta {
  /** Code de locale courant (par ex. 'en-US') */
  locale: string;
  /** Paramètres de route extraits de l'URL */
  params: Record<string, string>;
  /** Segments du chemin d'URL */
  segments: string[];
  /** ID du document courant (si édition d'un document existant) */
  docId: string | null;
  /** Titre du document courant */
  title: string;
}

Motif : /{country}/{lang}/products
Chemin : /us/en/products

Algorithme :
1. Normaliser les deux (supprimer les barres obliques finales)
2. Diviser en segments : ["us", "en", "products"] et ["{country}", "{lang}", "products"]
3. Faire correspondre le nombre de segments (doit être identique)
4. Pour chaque paire de segments :
   - Si le motif commence par : ou {}, extraire comme paramètre
   - Sinon, la correspondance doit être exacte
5. Retourner : { country: "us", lang: "en" }

// Liaison simple (utilise le champ "code" pour la recherche)
{ "lang": "language" }

// Liaison détaillée (champ slug personnalisé)
{
  "lang": {
    "schemaName": "language",
    "slugField": "code"
  },
  "slug": {
    "schemaName": "article",
    "slugField": "slug"
  }
}