CEL Scripting in Template Builder

Seu script                     O mecanismo                   Resultado
    |                              |                              |
    v                              v                              v
documents.get("article", "intro") --> Busca no banco de dados --> { headline: "Bem-vindo", body: "..." }
         .headline                --> Extrai o campo          --> "Bem-vindo"

// Acessar o campo de preço do documento atual
doc.price

// Calcular o total a partir dos campos do documento atual
doc.price * doc.quantity

// Condição baseada no status do documento atual
doc.status == "published" ? doc.title : "Rascunho: " + doc.title

// Armazenado no CMS como: article / welcome-post
{
  "headline": "Bem-vindo à nossa plataforma",
  "author": "Sarah Chen",
  "body": "Estamos felizes em anunciar...",
  "tags": ["announcement", "news"]
}

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

{
  "headline": "Bem-vindo à nossa plataforma",
  "author": "Sarah Chen",
  "body": "Estamos felizes em anunciar...",
  "tags": ["announcement", "news"]
}

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

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

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

// Obter todos os países
documents.find("country")

[
  { "code": "us", "name": "Estados Unidos", "flag": "US" },
  { "code": "sa", "name": "Arábia Saudita", "flag": "SA" },
  { "code": "gb", "name": "Reino Unido", "flag": "GB" }
]

// Obter países com um filtro
documents.find("country", { "where": { "code": "us" } })

[
  { "code": "us", "name": "Estados Unidos", "flag": "US" }
]

// Se meta.locale for "fr", retorna a tradução francesa mesclada ao documento-base
documents.get("greeting", "welcome").headline

// Sempre buscar a tradução em espanhol
documents.translated("greeting", "welcome", "es").headline

// Buscar a tradução com base em um parâmetro da URL
documents.translated("product", meta.params.id, meta.params.lang).description

// Comparar traduções
documents.translated("article", "intro", "en").title + " / " + documents.translated("article", "intro", "fr").title

// Documento-base: greeting / welcome
{ "headline": "Bem-vindo", "subheadline": "Bem-vindo à nossa plataforma" }

// Tradução (idioma: "fr")
{ "headline": "Bienvenue", "subheadline": "Bienvenue sur notre plateforme" }

// Tradução (idioma: "es")
{ "headline": "Bienvenido", "subheadline": "Bienvenido a nuestra plataforma" }

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

// Tradução explícita para espanhol
documents.translated("greeting", "welcome", "es").headline
// Retorna: "Bienvenido"

// Padrão alternativo para traduções ausentes
documents.translated("greeting", "welcome", meta.params.lang) != null
  ? documents.translated("greeting", "welcome", meta.params.lang).headline
  : documents.get("greeting", "welcome").headline

{
  "headline": "Crie mais rápido, publique com inteligência",
  "subheadline": "O CMS moderno para desenvolvedores"
}

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

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

// country / sa
{ "code": "sa", "name": "Arábia Saudita", "flag": "SA", "languages": ["ar", "en"] }

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

meta.locale == "ar-SA" ? "Boas-vindas a todos" : "Boas-vindas"

{ "headline": "Notícias dos EUA", "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
  : "Artigo não encontrado"

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

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

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

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

// Obter o nome do país
documents.get("country", meta.params.country).name

// Obter a lista localizada de produtos com base no país
documents.find("product", { "where": { "country": meta.params.country } })

// Combinado: mostrar uma saudação específica do país no idioma do usuário
documents.get("greeting", meta.params.lang).headline + " de " + documents.get("country", meta.params.country).name

// Obter o primeiro segmento (frequentemente o código do idioma)
meta.segments[0]

// Verificar a profundidade do caminho
size(meta.segments) > 2 ? "profundo" : "superficial"

// Verificar se estamos na seção administrativa
"admin" in meta.segments ? "modo administrativo" : "modo público"

// Alternativa: usar o segmento se o parâmetro não estiver associado
has(meta.params.lang) ? meta.params.lang : meta.segments[0]

// Verificar a localidade para idiomas RTL
meta.locale == "ar-SA" || meta.locale == "he-IL" ? "rtl" : "ltr"

// Obter somente a parte do idioma
meta.locale.split("-")[0]  // Não suportado — use meta.params.lang

// Acessar um parâmetro nomeado
meta.params.lang           // "ko"
meta.params.country        // "us"
meta.params.slug           // "welcome-post"

// Verificar se um parâmetro existe
has(meta.params.category)  // true/false

// Usar em uma busca de documento
documents.get("greeting", meta.params.lang)
documents.ref("airports").get(meta.params.code)

// Disponível somente ao editar documentos existentes
meta.docId != null ? "editando" : "criando novo"

// Usar em lógica condicional
meta.docId != null ? documents.get("article", meta.docId).status : "rascunho"

// Usar para exibição
"Editando: " + meta.title

// Condicional baseada no título
meta.title.contains("Rascunho") ? "em andamento" : "publicado"

// Abordagem tradicional
documents.get("airports", meta.params.code).name

// Usando ref() — schema separado do identificador dinâmico
documents.ref("airports").get(meta.params.code).name

documents.get("schema", "identifier")       // Obter um documento
documents.get("schema", "id").fieldName     // Obter um campo específico
documents.find("schema")                    // Obter todos os documentos
documents.find("schema", { "where": {...}}) // Consulta filtrada
documents.ref("schema").get(identifier)     // Busca encadeada
documents.translated("schema", "id", "fr")  // Obter com localidade explícita

meta.locale          // "en-US", "ar-SA" etc.
meta.params.xyz      // Parâmetro da URL chamado "xyz"
meta.segments        // Caminho da URL como array
meta.segments[0]     // Primeiro segmento do caminho
meta.docId           // ID do documento atual (ou null)
meta.title           // Título do documento atual
doc.fieldName        // Valor do campo do documento atual (no contexto do editor)

// Comparação
==  !=  <  <=  >  >=

// Lógica
&&  ||  !

// Ternário (if-else)
condition ? valueIfTrue : valueIfFalse

// Pertencimento
"value" in listOrMap

size(list)                    // Contar itens
size(string)                  // Comprimento da string
"text".startsWith("te")       // true
"text".endsWith("xt")         // true
"text".contains("ex")         // true
has(object.property)          // Verificar se a propriedade existe
hasProperty(obj, "key")       // Verificar se o objeto possui a chave (sintaxe alternativa)

// Futuro: chamar serviços externos via MCP
mcp.translate(meta.params.text, "en", meta.params.lang)
mcp.analyze(documents.get("article", meta.params.id).body)

// Futuro: geração de conteúdo com 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"])

// O artigo armazena o ID do autor; buscar o nome do autor
documents.get("author", documents.get("article", "intro").authorId).name

// Abordagem tradicional
documents.get("country", documents.get("airport", meta.params.code).countryCode).name

// Usando ref() — mais claro quando o schema é conhecido e o identificador é dinâmico
documents.ref("country").get(documents.get("airport", meta.params.code).countryCode).name

// Aeroporto → País → Região → Continente
documents.get("continent",
  documents.get("region",
    documents.get("country",
      documents.get("airport", meta.params.code).countryCode
    ).regionCode
  ).continentCode
).name

// Obter o nome localizado do país de um aeroporto
documents.translated("country",
  documents.get("airport", meta.params.code).countryCode,
  meta.params.lang
).name

{
  "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" }
  ]
}

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

  {
    "lang": "language"
  }

// 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 {
  /** Código da localidade atual (por exemplo, 'en-US') */
  locale: string;
  /** Parâmetros de rota extraídos da URL */
  params: Record<string, string>;
  /** Segmentos do caminho da URL */
  segments: string[];
  /** ID do documento atual (se estiver editando um documento existente) */
  docId: string | null;
  /** Título do documento atual */
  title: string;
}

Padrão: /{country}/{lang}/products
Caminho: /us/en/products

Algoritmo:
1. Normalizar ambos (remover barras finais)
2. Dividir em segmentos: ["us", "en", "products"] e ["{country}", "{lang}", "products"]
3. Comparar a quantidade de segmentos (deve ser igual)
4. Para cada par de segmentos:
   - Se o padrão começar com : ou {}, extrair como parâmetro
   - Caso contrário, deve corresponder exatamente
5. Retornar: { country: "us", lang: "en" }

// Associação simples (usa o campo "code" para a busca)
{ "lang": "language" }

// Associação detalhada (campo slug personalizado)
{
  "lang": {
    "schemaName": "language",
    "slugField": "code"
  },
  "slug": {
    "schemaName": "article",
    "slugField": "slug"
  }
}