CEL Scripting in Template Builder

Scriptul tău                    Motorul                        Rezultat
    |                              |                              |
    v                              v                              v
documents.get("article", "intro") --> Preia din baza de date --> { headline: "Bun venit", body: "..." }
         .headline                --> Extrage câmpul          --> "Bun venit"

// Accesează câmpul de preț al documentului curent
doc.price

// Calculează totalul din câmpurile documentului curent
doc.price * doc.quantity

// Condiție bazată pe starea documentului curent
doc.status == "published" ? doc.title : "Ciornă: " + doc.title

// Stocat în CMS ca: article / welcome-post
{
  "headline": "Bine ai venit pe platforma noastră",
  "author": "Sarah Chen",
  "body": "Suntem încântați să anunțăm...",
  "tags": ["announcement", "news"]
}

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

{
  "headline": "Bine ai venit pe platforma noastră",
  "author": "Sarah Chen",
  "body": "Suntem încântați să anunțăm...",
  "tags": ["announcement", "news"]
}

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

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

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

// Obține toate țările
documents.find("country")

[
  { "code": "us", "name": "Statele Unite", "flag": "US" },
  { "code": "sa", "name": "Arabia Saudită", "flag": "SA" },
  { "code": "gb", "name": "Regatul Unit", "flag": "GB" }
]

// Obține țările cu un filtru
documents.find("country", { "where": { "code": "us" } })

[
  { "code": "us", "name": "Statele Unite", "flag": "US" }
]

// Dacă meta.locale este "fr", returnează traducerea în franceză îmbinată cu documentul de bază
documents.get("greeting", "welcome").headline

// Preia întotdeauna traducerea în spaniolă
documents.translated("greeting", "welcome", "es").headline

// Preia traducerea pe baza parametrului din URL
documents.translated("product", meta.params.id, meta.params.lang).description

// Compară traduceri
documents.translated("article", "intro", "en").title + " / " + documents.translated("article", "intro", "fr").title

// Document de bază: greeting / welcome
{ "headline": "Bun venit", "subheadline": "Bun venit pe platforma noastră" }

// Traducere (limba: "fr")
{ "headline": "Bienvenue", "subheadline": "Bienvenue sur notre plateforme" }

// Traducere (limba: "es")
{ "headline": "Bienvenido", "subheadline": "Bienvenido a nuestra plataforma" }

// Cu meta.locale = "fr"
documents.get("greeting", "welcome").headline
// Returnează: "Bienvenue"

// Traducere explicită în spaniolă
documents.translated("greeting", "welcome", "es").headline
// Returnează: "Bienvenido"

// Model de rezervă pentru traduceri lipsă
documents.translated("greeting", "welcome", meta.params.lang) != null
  ? documents.translated("greeting", "welcome", meta.params.lang).headline
  : documents.get("greeting", "welcome").headline

{
  "headline": "Construiește mai rapid, lansează mai inteligent",
  "subheadline": "CMS-ul modern pentru dezvoltatori"
}

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

// country / us
{ "code": "us", "name": "Statele Unite", "flag": "US", "languages": ["en", "es"] }

// country / sa
{ "code": "sa", "name": "Arabia Saudită", "flag": "SA", "languages": ["ar", "en"] }

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

meta.locale == "ar-SA" ? "Bun venit, tuturor" : "Bun venit"

{ "headline": "Știri din SUA", "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
  : "Articolul nu a fost găsit"

documents.get("article", "intro").author != null
  ? documents.get("article", "intro").author
  : "Autor necunoscut"

"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": "Bun venit", "subheadline": "Bun venit pe platforma noastră", "ctaText": "Începe", "ctaUrl": "/ko/get-started" }

// greeting / en
{ "code": "en", "headline": "Bun venit", "subheadline": "Bun venit pe platforma noastră", "ctaText": "Începe", "ctaUrl": "/en/get-started" }

// greeting / ja
{ "code": "ja", "headline": "Bun venit", "subheadline": "Bun venit pe platforma noastră", "ctaText": "Start", "ctaUrl": "/ja/get-started" }

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

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

// Obține numele țării
documents.get("country", meta.params.country).name

// Obține lista de produse localizată în funcție de țară
documents.find("product", { "where": { "country": meta.params.country } })

// Combinat: arată salutul specific țării în limba utilizatorului
documents.get("greeting", meta.params.lang).headline + " din " + documents.get("country", meta.params.country).name

// Obține primul segment (adesea codul limbii)
meta.segments[0]

// Verifică adâncimea căii
size(meta.segments) > 2 ? "adâncă" : "superficială"

// Verifică dacă suntem în secțiunea de administrare
"admin" in meta.segments ? "mod admin" : "mod public"

// Rezervă: folosește segmentul dacă parametrul nu este asociat
has(meta.params.lang) ? meta.params.lang : meta.segments[0]

// Verifică localizarea pentru limbile RTL
meta.locale == "ar-SA" || meta.locale == "he-IL" ? "rtl" : "ltr"

// Obține doar partea de limbă
meta.locale.split("-")[0]  // Nu este acceptat - folosește meta.params.lang în schimb

// Accesează un parametru numit
meta.params.lang           // "ko"
meta.params.country        // "us"
meta.params.slug           // "welcome-post"

// Verifică dacă parametrul există
has(meta.params.category)  // true/false

// Folosește-l pentru a prelua un document
documents.get("greeting", meta.params.lang)
documents.ref("airports").get(meta.params.code)

// Acces pe index (0-based)
meta.segments[0]           // Primul segment
meta.segments[1]           // Al doilea segment

// Verifică lungimea
size(meta.segments)        // Numărul de segmente

// Verifică apartenența
"products" in meta.segments  // Calea include "products"?

// Disponibil doar când editezi documente existente
meta.docId != null ? "editare" : "creare nouă"

// Folosește în logică condițională
meta.docId != null ? documents.get("article", meta.docId).status : "draft"

// Folosește pentru afișare
"În editare: " + meta.title

// Condițional în funcție de titlu
meta.title.contains("Draft") ? "în lucru" : "publicat"

// Abordare tradițională
documents.get("airports", meta.params.code).name

// Folosind ref() - schema separată de identificatorul dinamic
documents.ref("airports").get(meta.params.code).name

documents.get("schema", "identifier")       // Preia un document
documents.get("schema", "id").fieldName     // Preia un câmp specific
documents.find("schema")                    // Preia toate documentele
documents.find("schema", { "where": {...}}) // Interogare filtrată
documents.ref("schema").get(identifier)     // Căutare în lanț
documents.translated("schema", "id", "fr")  // Preia cu localizare explicită

meta.locale          // "en-US", "ar-SA", etc.
meta.params.xyz      // Parametrul de URL numit "xyz"
meta.segments        // Calea URL ca array: ["articles", "intro"]
meta.segments[0]     // Primul segment de cale
meta.docId           // ID-ul documentului curent (sau null)
meta.title           // Titlul documentului curent
doc.fieldName        // Valoarea câmpului documentului curent (în contextul editorului)

// Comparație
==  !=  <  <=  >  >=

// Logică
&&  ||  !

// Ternar (if-else)
condiție ? valoareDacăAdevărat : valoareDacăFals

// Apartenență
"valoare" in listOrMap

size(list)                    // Numără elementele
size(string)                  // Lungimea stringului
"text".startsWith("te")       // true
"text".endsWith("xt")         // true
"text".contains("ex")         // true
has(object.property)          // Verifică dacă proprietatea există
hasProperty(obj, "key")       // Verifică dacă obiectul are cheia (sintaxă alternativă)

// Viitor: apelarea serviciilor externe via MCP
mcp.translate(meta.params.text, "en", meta.params.lang)
mcp.analyze(documents.get("article", meta.params.id).body)

// Viitor: generare de conținut cu AI
ai.summarize(documents.get("article", meta.params.id).body, 100)
ai.translate(meta.params.text, meta.params.targetLang)
ai.classify(meta.params.input, ["pozitiv", "negativ", "neutru"])

// Articolul stochează ID-ul autorului, preia numele autorului
documents.get("author", documents.get("article", "intro").authorId).name

// Abordare tradițională
documents.get("country", documents.get("airport", meta.params.code).countryCode).name

// Folosind ref() - mai clar când schema este cunoscută, dar identificatorul este dinamic
documents.ref("country").get(documents.get("airport", meta.params.code).countryCode).name

// Aeroport → Țară → Regiune → Continent
documents.get("continent",
  documents.get("region",
    documents.get("country",
      documents.get("airport", meta.params.code).countryCode
    ).regionCode
  ).continentCode
).name

// Obține numele localizat al țării pentru un aeroport
documents.translated("country",
  documents.get("airport", meta.params.code).countryCode,
  meta.params.lang
).name

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

// Rezolvă numele autorului
documents.get("author", documents.get("article", meta.params.slug).authorId).name

// Rezolvă categoria cu rezervă
documents.get("article", meta.params.slug).categoryId != null
  ? documents.get("category", documents.get("article", meta.params.slug).categoryId).name
  : "Fără categorie"

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

// country / us
{ "code": "us", "name": "Statele Unite", "currencyCode": "usd" }

// currency / usd
{ "code": "usd", "symbol": "$", "name": "Dolarul SUA" }

// Lanț Aeroport → Țară → Monedă
documents.get("currency",
  documents.get("country",
    documents.get("airport", meta.params.code).countryCode
  ).currencyCode
).symbol
// Pentru JFK: returnează "$"

// Într-un document de produs, preia detalii despre categoria asociată
documents.get("category", doc.categoryId).description

// Cost de livrare calculat pe baza țării de origine a produsului
documents.get("shipping-rates", doc.originCountry).baseRate * doc.weight

// Obține autorul articolului, apoi alte articole ale autorului (atenție la numărul de preluări)
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" }

// Căutare dinamică a schemei în funcție de 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

// Greșit: preia același document de două ori
documents.get("author", documents.get("article", "intro").authorId).name + " - " +
documents.get("author", documents.get("article", "intro").authorId).bio

// Mai bine: folosește o condiție pentru a verifica o singură dată
documents.get("article", "intro").authorId != null
  ? documents.get("author", documents.get("article", "intro").authorId).name
  : "Autor necunoscut"

{
  "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": "Bun venit",
  "subheadline": "Bun venit pe platforma noastră",
  "ctaText": "Începe",
  "ctaUrl": "/ko/get-started"
}

{
  "code": "en",
  "headline": "Bun venit",
  "subheadline": "Bun venit pe platforma noastră",
  "ctaText": "Începe",
  "ctaUrl": "/en/get-started"
}

{
  "code": "ja",
  "headline": "Bun venit",
  "subheadline": "Bun venit pe platforma noastră",
  "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 {
  /** Codul localizării curente (de ex., 'en-US') */
  locale: string;
  /** Parametrii de rută extrași din URL */
  params: Record<string, string>;
  /** Segmentele căii URL */
  segments: string[];
  /** ID-ul documentului curent (dacă editezi un document existent) */
  docId: string | null;
  /** Titlul documentului curent */
  title: string;
}

Model: /{country}/{lang}/products
Cale:   /us/en/products

Algoritm:
1. Normalizează ambele (elimină slash-urile finale)
2. Împarte în segmente: ["us", "en", "products"] și ["{country}", "{lang}", "products"]
3. Potrivește numărul segmentelor (trebuie să fie egal)
4. Pentru fiecare pereche de segmente:
   - Dacă modelul începe cu : sau {}, extrage ca parametru
   - Altfel, trebuie să se potrivească exact
5. Returnează: { country: "us", lang: "en" }

// Asociere simplă (folosește câmpul "code" pentru căutare)
{ "lang": "language" }

// Asociere detaliată (câmp slug personalizat)
{
  "lang": {
    "schemaName": "language",
    "slugField": "code"
  },
  "slug": {
    "schemaName": "article",
    "slugField": "slug"
  }
}