CEL Scripting in Template Builder

Praktiline juhend CEL-avaldiste kirjutamiseks CMS-is.

Kuidas CEL töötab

CEL (Common Expression Language ehk levinud avaldiste keel) on meie CMS-i sisseehitatud kerge skriptikeel. See võimaldab kirjutada dünaamilisi avaldisi, mis hangivad andmeid dokumentidest, loevad URL-i parameetreid ja arvutavad väärtusi käigu pealt.

CEL-skripti käivitamisel toimub järgmine:

Sinu skript                    Mootor                         Tulemus
    |                              |                              |
    v                              v                              v
documents.get("article", "intro") --> Hangib andmebaasist --> { headline: "Welcome", body: "..." }
         .headline                --> Eraldab välja        --> "Welcome"

Mõtle CEL-ist kui kirjutuskaitstud päringukeeleks. See ei saa andmebaasis midagi muuta – see ainult loeb andmeid ja tagastab arvutatud tulemuse. Seetõttu on seda turvaline kasutada kõikjal CMS-is.

Põhikomponendid

Igal CEL-avaldise käsutuses on kolm objekti:

Viitamine iseendale objektiga doc

Dokumendiredaktoris CEL-avaldiseid kirjutades saad praeguse dokumendi väljade väärtustele ligi objekti doc kaudu. See võimaldab luua arvutatud välju ja väljadevahelisi viiteid.

// Praeguse dokumendi hinnavälja kasutamine
doc.price

// Praeguse dokumendi väljade põhjal kogusumma arvutamine
doc.price * doc.quantity

// Tingimus praeguse dokumendi oleku põhjal
doc.status == "published" ? doc.title : "Draft: " + doc.title

Objekt doc sisaldab kõiki redigeeritava dokumendi väljade väärtusi. See on kasulik järgmisteks toiminguteks:

• arvutatud väljad (nt doc.price * doc.quantity)
• dokumendi olekul põhinev tingimuslik kuvamisloogika
• valideerimislaadsed avaldised

Dokumentide hankimine

CEL-i kõige võimsam funktsioon on dokumentide hankimine CMS-i mis tahes kohast.

Ühe dokumendi hankimine

Süntaks: documents.get(schemaName, identifier)

Oletame, et sul on article-dokument identifikaatoriga "welcome-post":

// CMS-is salvestatud kujul: article / welcome-post
{
  "headline": "Welcome to Our Platform",
  "author": "Sarah Chen",
  "body": "We're excited to announce...",
  "tags": ["announcement", "news"]
}

Kogu dokumendi hankimiseks:

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

Tagastab:

{
  "headline": "Welcome to Our Platform",
  "author": "Sarah Chen",
  "body": "We're excited to announce...",
  "tags": ["announcement", "news"]
}

Ainult pealkirja hankimiseks:

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

Tagastab: "Welcome to Our Platform"

Autori hankimiseks:

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

Tagastab: "Sarah Chen"

URL-i parameetrite kasutamine

Kui lehel on dünaamilised marsruudid (nt /articles/[slug]), saad URL-i parameetri saamiseks ja õige dokumendi hankimiseks kasutada meta.params-i.

Kui keegi külastab aadressi /articles/welcome-post:

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

Tagastab: "Welcome to Our Platform"

Nii luuakse dünaamilisi lehti – sama CEL-skript töötab kõigi artiklite puhul, kasutades lihtsalt URL-is olevat slug'i.

Mitme dokumendi hankimine

Süntaks: documents.find(schemaName) või documents.find(schemaName, filter)

// Kõigi riikide hankimine
documents.find("country")

Tagastab:

[
  { "code": "us", "name": "United States", "flag": "US" },
  { "code": "sa", "name": "Saudi Arabia", "flag": "SA" },
  { "code": "gb", "name": "United Kingdom", "flag": "GB" }
]

// Filtriga riikide hankimine
documents.find("country", { "where": { "code": "us" } })

Tagastab:

[
  { "code": "us", "name": "United States", "flag": "US" }
]

Tõlked

CEL toetab tõlgitud dokumendisisu hankimist kahel viisil: lokaa­dil põhinev automaatne tõlge ja sõnaselge tõlkeotsing.

Automaatne tõlge meta.locale kaudu

Kui meta.locale on määratud (näiteks marsruudi parameetrite või kasutaja eelistuste kaudu), ühendab documents.get() automaatselt tõlgitud sisu:

// Kui meta.locale on "fr", tagastab baasdokumendiga ühendatud prantsuskeelse tõlke
documents.get("greeting", "welcome").headline

Kuidas see töötab:

1. Hangitakse baasdokumendi sisu
2. Kui meta.locale ei ole "en" ega "en-US", otsitakse tõlget tabelist translations
3. Tõlgitud väljad ühendatakse baassisuga: { ...baseContent, ...translatedContent }

See tähendab, et tõlgitud väljad kirjutavad baasväljad üle, tõlkimata väljad aga langevad tagasi baasdokumendi väärtustele.

Sõnaselge tõlge funktsiooniga documents.translated()

Kui on vaja hankida kindel tõlge sõltumata praegusest lokaadist:

Süntaks: documents.translated(schemaName, identifier, locale)

// Hispaaniakeelse tõlke hankimine
documents.translated("greeting", "welcome", "es").headline

// URL-i parameetri põhjal tõlke hankimine
documents.translated("product", meta.params.id, meta.params.lang).description

// Tõlgete võrdlemine
documents.translated("article", "intro", "en").title + " / " + documents.translated("article", "intro", "fr").title

Tõlkenäide

Tõlgetega tervitusdokumendid:

// Baasdokument: greeting / welcome
{ "headline": "Welcome", "subheadline": "Welcome to our platform" }

// Tõlge (keel: "fr")
{ "headline": "Bienvenue", "subheadline": "Bienvenue sur notre plateforme" }

// Tõlge (keel: "es")
{ "headline": "Bienvenido", "subheadline": "Bienvenido a nuestra plataforma" }

CEL-skriptid:

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

// Sõnaselge hispaaniakeelne tõlge
documents.translated("greeting", "welcome", "es").headline
// Tagastab: "Bienvenido"

// Varumuster puuduvate tõlgete korral
documents.translated("greeting", "welcome", meta.params.lang) != null
  ? documents.translated("greeting", "welcome", meta.params.lang).headline
  : documents.get("greeting", "welcome").headline

Praktilised näited

Näide 1: kangelõigu pealkiri teisest dokumendist

Sul on hero-block, mis peab kuvama article-dokumendist hangitud pealkirja.

Sinu artiklidokument (identifikaator: "homepage-hero"):

{
  "headline": "Build Faster, Ship Smarter",
  "subheadline": "The modern CMS for developers"
}

Kangelõigu pealkirjavälja CEL-skript:

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

Tulemus: kangelõik kuvab "Build Faster, Ship Smarter"

Näide 2: riigi nimi koodi põhjal

Loоб lehte aadressil /countries/[code] ja soovid kuvada riigi täieliku nime.

Sinu riigidokumendid:

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

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

CEL-skript:

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

Kui keegi külastab aadressi /countries/us:

• meta.params.code = "us"
• Tulemus: "United States"

Kui keegi külastab aadressi /countries/sa:

• meta.params.code = "sa"
• Tulemus: "Saudi Arabia"

Näide 3: lokaadipõhine tingimuslik sisu

Kuva kasutaja lokaadi põhjal erinevaid pealkirju.

meta.locale == "ar-SA" ? "Welcome, everyone" : "Welcome"

Kui lokaat on "ar-SA": tagastab "Welcome, everyone" Kui lokaat on midagi muud: tagastab "Welcome"

Näide 4: aheldatud dokumendiotsingud

Sinu article-dokumendil on väli countryCode ja soovid saada riigi täieliku nime.

Artiklidokument:

{ "headline": "News from the US", "countryCode": "us" }

CEL-skript:

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

Toimub järgmine:

1. documents.get("article", "us-news") tagastab { "headline": "News from the US", "countryCode": "us" }
2. .countryCode eraldab väärtuse "us"
3. documents.get("country", "us") tagastab { "code": "us", "name": "United States", ... }
4. .name eraldab väärtuse "United States"

Tulemus: "United States"

Näide 5: varuväärtused

Kui dokumenti ei pruugi olemas olla, saad määrata varuväärtuse:

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

Või kontrolli, kas konkreetne väli on olemas:

documents.get("article", "intro").author != null
  ? documents.get("article", "intro").author
  : "Unknown Author"

Näide 6: loenditega töötamine

Sinu artiklil on sildid ja soovid kontrollida, kas konkreetne silt on olemas:

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

Tagastab: true, kui artiklil on silt "featured"

Esimese sildi hankimine:

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

Tagastab: "announcement" (esimene silt)

Siltide loendamine:

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

Tagastab: 2 (siltide arv)

Parameetrilised marsruudid ja meta.params

Parameetrilised marsruudid on dünaamiliste lokaliseeritud lehtede loomise võti. Kui määrad marsruudimustri, näiteks /{lang}/landingPage, eraldab CMS URL-ist parameetrid ja teeb need kättesaadavaks meta.params kaudu.

Kuidas marsruudi parameetrid töötavad

Marsruudimustri määratlus: Marsruudid kasutavad dünaamiliste lõikude määratlemiseks süntaksit :paramName või {paramName}:

Parameetrite sidumised: Iga marsruudi parameetri saab valideerimiseks siduda dokumendiskeemiga:

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

See sidumine ütleb CMS-ile:

1. eralda URL-ist lõik lang
2. valideeri see language-skeemi vastu (otsi dokumenti, mille content.code sobib)
3. kui väärtus on sobiv, tee kogu dokument lahendatud parameetrites kättesaadavaks

Näide: keelepõhine sihtleht

Marsruudi konfiguratsioon:

• Tee: /{lang}/landingPage
• Muster: /{lang}/landingPage
• Parameetri sidumised: { "lang": "language" }

Sinu tervitusdokumendid:

// 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" }

Lokaliseeritud sisu hankiv CEL-skript:

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

Lahendamise tulemus:

meta.segments – töötlemata URL-i tee

meta.segments pakub töötlemata URL-i teed massiivina. See on kasulik, kui vajad positsioonipõhist ligipääsu nimega parameetrite asemel.

Millal kasutada meta.segments-i ja millal meta.params-i

Objekti meta täielik viide

Objekt meta sisaldab kogu praeguse päringu konteksti:

meta.locale

Lokaat järgib BCP 47 vormingut (keel-piirkond):

// RTL-keelte kontrollimine
meta.locale == "ar-SA" || meta.locale == "he-IL" ? "rtl" : "ltr"

// Ainult keeleosa hankimine
meta.locale.split("-")[0]  // Pole toetatud – kasuta selle asemel meta.params.lang-i

meta.params

Marsruudiparameetrid on alati stringid. CMS valideerib need enne hindamist seotud skeemide vastu:

// Nimega parameetri kasutamine
meta.params.lang           // "ko"
meta.params.country        // "us"
meta.params.slug           // "welcome-post"

// Parameetri olemasolu kontrollimine
has(meta.params.category)  // true/false

// Kasutamine dokumendi hankimisel
documents.get("greeting", meta.params.lang)
documents.ref("airports").get(meta.params.code)

meta.segments

Töötlemata URL-i segmendid massiivina:

meta.segments[0]           // Esimene segment
meta.segments[1]           // Teine segment
size(meta.segments)        // Segmentide arv
"products" in meta.segments  // Kas tee sisaldab sõna "products"?

meta.docId

Praeguse dokumendi UUID, mis on kasulik iseendale viitavates skriptides:

meta.docId != null ? "editing" : "creating new"
meta.docId != null ? documents.get("article", meta.docId).status : "draft"

meta.title

Praeguse dokumendi pealkiri:

"Editing: " + meta.title
meta.title.contains("Draft") ? "work in progress" : "published"

documents.ref() – aheldatud otsingud

Kui skeem on teada, kuid identifikaator on dünaamiline, annab ref() puhtama süntaksi:

documents.get("airports", meta.params.code).name
documents.ref("airports").get(meta.params.code).name

Mõlemad on samaväärsed, kuid ref() muudab dünaamilise osa selgemaks.

Kiirviide

Dokumentide hankimine

documents.get("schema", "identifier")       // Hangi üks dokument
documents.get("schema", "id").fieldName     // Hangi konkreetne väli
documents.find("schema")                    // Hangi kõik dokumendid
documents.find("schema", { "where": {...}}) // Filtreeritud päring
documents.ref("schema").get(identifier)     // Aheldatud otsing
documents.translated("schema", "id", "fr")  // Hangi määratud lokaadiga

Konteksti muutujad

meta.locale          // "en-US", "ar-SA" jne
meta.params.xyz      // URL-i parameeter nimega "xyz"
meta.segments        // URL-i tee massiivina
meta.segments[0]     // Tee esimene segment
meta.docId           // Praeguse dokumendi ID (või null)
meta.title           // Praeguse dokumendi pealkiri
doc.fieldName        // Praeguse dokumendi välja väärtus redaktori kontekstis

Operaatorid

==  !=  <  <=  >  >=
&&  ||  !
condition ? valueIfTrue : valueIfFalse
"value" in listOrMap

Levinud funktsioonid

size(list)                    // Üksuste arv
size(string)                  // Stringi pikkus
"text".startsWith("te")       // true
"text".endsWith("xt")         // true
"text".contains("ex")         // true
has(object.property)          // Kontrolli omaduse olemasolu
hasProperty(obj, "key")       // Kontrolli objekti võtme olemasolu

Veateated

Kui midagi läheb valesti, näed üht järgmistest teadetest:

Laiendatavus ja tulevased võimalused

CEL-i mootor on loodud laiendatavust silmas pidades. Kavandatud tulevikuvõimalused hõlmavad järgmist:

Kavandamisel: MCP-serveri integratsioon

mcp.translate(meta.params.text, "en", meta.params.lang)
mcp.analyze(documents.get("article", meta.params.id).body)

Kavandamisel: tehisintellekti võimalused

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"])

Need võimalused lisatakse registreeritud funktsioonide süsteemi kaudu, säilitades olemasolevate skriptide tagasiühilduvuse.

Näpunäited

1. Kasuta automaattäitmist – kirjuta documents. või meta. ja redaktor kuvab saadaolevad valikud
2. Alusta lihtsalt – testi esmalt documents.get("schema", "id")-ga ja lisa seejärel .fieldName
3. Kontrolli nullväärtusi – kui dokumenti ei pruugi olla, lisa varuvariant kujul != null ? ... : ...
4. Ära hangi liiga palju – iga documents.get() või documents.find() arvestatakse 50 dokumendi piirangu sisse
5. Eelista meta.params-i meta.segments-ile – nimega parameetrid on valideeritud ja usaldusväärsemad
6. Kasuta valikuliste parameetrite jaoks has()-i – kontrolli enne ligipääsu has(meta.params.category) abil
7. Kasuta dünaamiliste identifikaatorite puhul documents.ref()-i – selgem süntaks, kui skeem on staatiline, kuid identifikaator dünaamiline
8. Kasuta iseendale viitamiseks doc.fieldName-i – pääsed arvutatud avaldiste sees ligi praeguse dokumendi väljadele

Dokumendilt dokumendile viited

See jaotis käsitleb täpsemaid mustreid dokumentide ühendamiseks ja relatsiooniliste sisustruktuuride loomiseks.

Põhiline viitemuster

Lihtsaim vorm: üks dokument viitab teisele identifikaatori kaudu.

documents.get("author", documents.get("article", "intro").authorId).name

Aheldatud otsingud funktsiooniga documents.ref()

Kui identifikaator on dünaamiline:

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

Mitmetasandilised viiteahelad

Sügavate seoste loomiseks ahelda mitu otsingut:

documents.get("continent",
  documents.get("region",
    documents.get("country",
      documents.get("airport", meta.params.code).countryCode
    ).regionCode
  ).continentCode
).name

Tõlkega viide

Ühenda dokumendiviited tõlgetega:

documents.translated("country",
  documents.get("airport", meta.params.code).countryCode,
  meta.params.lang
).name

Viitemustrid kasutusjuhtude kaupa

Muster 1: võõrvõtme otsing

Dokument salvestab teisele dokumendile viitava ID.

{ "title": "Tech Update", "authorId": "author-123", "categoryId": "cat-tech" }

documents.get("author", documents.get("article", meta.params.slug).authorId).name

documents.get("article", meta.params.slug).categoryId != null
  ? documents.get("category", documents.get("article", meta.params.slug).categoryId).name
  : "Uncategorized"

Muster 2: koodipõhised viited

Dokumendid viitavad üksteisele tähenduslike koodide, mitte UUID-de kaudu.

{ "code": "JFK", "name": "John F. Kennedy International", "countryCode": "us" }
{ "code": "us", "name": "United States", "currencyCode": "usd" }
{ "code": "usd", "symbol": "$", "name": "US Dollar" }

documents.get("currency",
  documents.get("country",
    documents.get("airport", meta.params.code).countryCode
  ).currencyCode
).symbol

Muster 3: iseendale viitamine doc-kontekstis

Kasuta doc-i arvutatud väljade puhul, mis viitavad teistele dokumentidele praeguse dokumendi väärtuste põhjal.

documents.get("category", doc.categoryId).description
documents.get("shipping-rates", doc.originCountry).baseRate * doc.weight

Muster 4: kahesuunalised viited

Kui dokumendid viitavad üksteisele, ole hankimispiirangute suhtes ettevaatlik.

documents.find("article", { "where": { "authorId": documents.get("article", meta.params.slug).authorId } })

Muster 5: polümorfsed viited

Kui väli võib viidata erinevatele skeemidele:

{ "type": "hero", "sourceType": "article", "sourceId": "welcome-post" }
{ "type": "hero", "sourceType": "product", "sourceId": "featured-item" }

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

Sõltuvuste jälgimine

Iga documents.get(), documents.find() ja documents.ref().get() kõne registreeritakse vahemälu kehtetuks muutmiseks. Kui viidatud dokument muutub, teab CMS, millised CEL-avaldised tuleb uuesti hinnata.

Jälgitavad sõltuvused hõlmavad:

• get: schema:identifier – konkreetse dokumendi sõltuvus
• ref: schema:identifier – sama mis get-i puhul, aheldatud süntaksi kaudu
• query: schema:* – skeemitaseme sõltuvus (mis tahes dokument selles skeemis)

Viidete head tavad

1. Minimeeri ahela sügavust – iga tase lisab latentsust ja suurendab hangete arvu
2. Puhverda vahetulemused – kui vajad sama pesastatud väärtust kaks korda, hangi vanemdokument üks kord
3. Kasuta nullikontrolle – viited võivad katkeda, kui dokumendid kustutatakse
4. Eelista UUID-dele koode – koodid on avaldistes loetavad ja keskkondade vahel stabiilsed
5. Jälgi hankimispiiranguid – keerukad viiteahelad võivad 50 hanke piirini kiiresti jõuda

Lisa A: täielik parameetrilise marsruudi näide

See juhend loob mitmekeelse sihtlehe, millele pääseb ligi aadressil /{lang}/landingPage.

1. samm: tervitusdokumendi skeemi loomine

Loo CMS-i halduses kohandatud skeem nimega greeting:

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

2. samm: tervitusdokumentide loomine

Loo iga keele jaoks dokument:

Dokument: greeting/ko

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

Dokument: greeting/en

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

Dokument: greeting/ja

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

3. samm: lehe loomine

Loo järgmise konfiguratsiooniga leht:

• Tee/muster: /{lang}/landingPage
• Olek: aktiivne
• Dünaamiliste lõikude vastendused: seo lang komponendiga language

4. samm: CEL-skriptidega plokkide lisamine

Lisa marsruudile kangelõik, kasutades iga välja jaoks järgmisi CEL-skripte:

Pealkirjaväli:

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

Alapealkirjaväli:

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

CTA teksti väli:

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

CTA URL-i väli:

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

5. samm: kasutamine Next.js-is

Lisa kõikehõlmav marsruut. ParametricRoutePage lahendab lehe, eraldab URL-ist meta.params-i, hindab CEL-i sidumised serveri poolel ja renderdab iga ploki registri kaudu – sa ei pea ise meta-konteksti looma ega madala taseme klienti kutsuma.

6. samm: marsruutide testimine

Lokaliseeritud sisu nägemiseks külasta järgmisi URL-e:

Lahendamise toimimine

Kui kasutaja külastab aadressi /ko/landingPage:

1. Marsruudi sobitamine: CMS sobitab mustri /{lang}/landingPage
2. Parameetri eraldamine: meta.params.lang = "ko"
3. Valideerimine: CMS kontrollib, et "ko" leidub language-skeemis
4. CEL-i hindamine: skriptid nagu documents.get("greeting", meta.params.lang) lahenduvad koreakeelseks sisuks
5. Vastus: lokaliseeritud plokid tagastatakse kliendile

Lisa B: tehniline viide

CelMeta-liides (TypeScript)

interface CelMeta {
  locale: string;
  params: Record<string, string>;
  segments: string[];
  docId: string | null;
  title: string;
}

Parameetrite eraldamise algoritm

Funktsioon extractParams töötleb URL-i teid:

Muster: /{country}/{lang}/products
Tee:    /us/en/products

Algoritm:
1. Normaliseeri mõlemad (eemalda lõpus olevad kaldkriipsud)
2. Jaga segmentideks
3. Võrdle segmentide arvu
4. Töötle iga segapaari:
   - Kui muster algab märgiga : või {}, eralda see parameetrina
   - Vastasel juhul peab see täpselt sobima
5. Tagasta: { country: "us", lang: "en" }

Toetatud parameetri sidumise vormingud

{ "lang": "language" }

{
  "lang": {
    "schemaName": "language",
    "slugField": "code"
  },
  "slug": {
    "schemaName": "article",
    "slugField": "slug"
  }
}

Dokumentide otsingu prioriteet

Kui hankida dokument funktsiooniga documents.get(schema, identifier):

1. UUID vaste: kui identifikaator on kehtiv UUID, hangitakse dokument välja id järgi
2. Koodiväli: kontrollitakse välja content.code
3. Slug'i väli: kontrollitakse välja content.slug
4. Pealkirja vaste: kontrollitakse välja title

See võimaldab paindlikult viidata dokumentidele mis tahes unikaalse identifikaatori kaudu.