Průvodce Sanity CMS: Jak jej používáme k publikování v 10 jazycích

Průvodce Sanity CMS: Jak jej používáme k publikování v 10 jazycích

Publikovali jsme přes 400 obsahových kusů napříč 4 webovými stránkami a 10 jazyky prostřednictvím Sanity CMS. Zde je shrnutí toho, co jsme se naučili, od návrhu schématu až po automatizované vícejazyčné publikování.

Sanity CMS je headless platforma pro obsah postavená kolem strukturovaného obsahu, Content Lake v reálném čase a přizpůsobitelného editoru založeného na Reactu nazvaného Sanity Studio. Pro dotazování využívá GROQ, pro bohatý obsah Portable Text a pro modelování obsahu přístup „schema-as-code“ (schéma jako kód). Tento průvodce pokrývá nastavení, návrh schématu, GROQ, Portable Text, vícejazyčnou architekturu a ceník.

Co je Sanity CMS?

Sanity je platforma pro strukturovaný obsah, kterou tým Sanity.io nazývá „operačním systémem pro obsah“. Na rozdíl od tradičních CMS, které ukládají HTML bloky do databáze, ukládá Sanity každý kousek obsahu jako strukturované JSON v spravovaném backendu zvaném Content Lake. Dotazujete se na něj pomocí GROQ nebo GraphQL a vykreslujete obsah v jakémkoli frontendu, který chcete: Next.js, React Native, Svelte, mobilní aplikace, CLI nástroj, cokoliv.

Společnosti, které jej používají, pokrývají celé spektrum. Nike, Figma, Puma a Cloudflare provozují Sanity v enterprise měřítku. Startupy jej používají, protože bezplatná verze je skutečně použitelná (více o cenách později). My jej používáme, protože nic jiného nám nedalo flexibilitu vybudovat plně automatizovanou publikační pipeline pro 10 jazyků.

Architektura Content Lake

Content Lake je spravovaný backend Sanity. Představte si jej jako hostované úložiště dokumentů, které se synchronizuje v reálném čase napříč všemi připojenými klienty. Když editor změní odstavec v Sanity Studio, jiný editor ho uvidí okamžitě, žádné tlačítko uložit, žádné konflikty při slučování, žádné migrace databáze.

Pod kapotou jsou dokumenty uloženy jako strukturované JSON s typovanými poli. Každá změna je sledována prostřednictvím transakčního logu, takže ve výchozím nastavení získáte úplnou historii verzí. Synchronizace v reálném čase využívá architekturu založenou na posluchačích (popisováno v dokumentaci architektury Sanity na GitHubu), která pushuje změny všem odběratelům prostřednictvím RxJS observables.

Čím se to liší například od databáze PostgreSQL s REST API? Content Lake zpracovává modelování obsahu, řízení přístupu, CDN cachování, transformace obrázků a spolupráci v reálném čase jako jednu spravovanou službu. Nespouštíte migrace. Nespravujete repliky. Pouze definujete schémata a dotazujete se na obsah.

Sanity Studio: Váš přizpůsobitelný editor

Sanity Studio je open-source aplikace v Reactu, která slouží jako vaše rozhraní pro editaci. Nejedná se o hostovaný administrační panel, ale o React aplikaci, která žije ve vašem codebase. Můžete přizpůsobit každý její aspekt: vlastní vstupní komponenty, podmíněná pole, akce dokumentů, vzory structure builderu a pluginy.

Spolupráce v reálném čase je vestavěná. Více editorů může pracovat na stejném dokumentu současně s indikátory přítomnosti a živými aktualizacemi. Pokud jste používali Google Docs, zážitek je podobný, vidíte kurzory a změny ostatních lidí v reálném čase.

Naše Studio nasazujeme pomocí npx sanity deploy, což jej hostuje na CDN Sanity na vlastní subdoméně. Můžete jej také hostovat sami, protože jde pouze o React aplikaci. Sanity jsme vysoko ohodnotili v našem porovnání headless CMS především kvůli flexibilitě Studia.

Jak nastavit projekt Sanity

Pro nastavení Sanity CMS nainstalujte CLI pomocí npm create sanity@latest, zvolte šablonu projektu, nakonfigurujte soubory schématu a spusťte npx sanity dev pro lokální spuštění Studia. Celý proces zabere méně než 5 minut.

Požadavky a instalace

Potřebujete Node.js 18+ a npm (nebo pnpm). To je vše. Spusťte inicializační příkaz:

npm create sanity@latest

# You'll be prompted for:
# - Login method (Google, GitHub, email)
# - Project name
# - Dataset name (default: "production")
# - Project template (blog, ecommerce, clean)
# - TypeScript? (recommended: yes)

CLI vygeneruje kostru projektu se vším, co potřebujete. Zde je, jak vypadá struktura projektu:

Vysvětlení struktury projektu

my-sanity-project/
├── schemas/              # Your content schemas (this is where you'll spend time)
│   ├── index.ts          # Schema registry -- imports and exports all types
│   ├── post.ts           # Document type definitions
│   └── blockContent.ts   # Rich text / Portable Text config
├── sanity.config.ts      # Main config -- plugins, Studio structure, dataset
├── sanity.cli.ts         # CLI config -- project ID, dataset
├── package.json
└── tsconfig.json

Soubor sanity.config.ts je váš vstupní bod. Zde je minimální konfigurace:

// sanity.config.ts
import { defineConfig } from 'sanity'
import { structureTool } from 'sanity/structure'
import { visionTool } from '@sanity/vision'
import { schemaTypes } from './schemas'

export default defineConfig({
  name: 'default',
  title: 'My Blog',
  projectId: 'your-project-id',
  dataset: 'production',
  plugins: [structureTool(), visionTool()],
  schema: { types: schemaTypes },
})

Plugin visionTool() vám poskytuje hřiště GROQ přímo ve Studiu, během vývoje jej budete používat neustále.

Nasazení vašeho Studia

Spusťte lokálně pomocí npx sanity dev (běží na localhost:3333). Až budete připraveni sdílet projekt s editory, nasaďte jej na CDN Sanity:

npx sanity deploy
# Prompts for a hostname, e.g., "my-blog"
# Deploys to https://my-blog.sanity.studio

Profesionální tip: po každé změně schématu spusťte npx sanity@latest schema deploy. Tím nahrajete své schéma do API Sanity, což umožní funkce jako GraphQL API a nástroje aware schématu (včetně MCP serveru, kterému se budeme věnovat později).

Návrh schématu v Sanity CMS

Schémata Sanity jsou definována jako objekty JavaScript nebo TypeScript ve vašem codebase. Každé schéma specifikuje typ dokumentu s poli, validačními pravidly a vlastními vstupními komponentami. Změny ve schématech jsou okamžité, nejsou vyžadovány žádné migrace databáze. Toto je přístup „schema-as-code“ a je to věc, která nás přesvědčila o Sanity oproti Contentful.

Typy polí a validace

Sanity dodává bohatou sadu typů polí. Zde jsou ta, která používáme nejčastěji:

Každé pole podporuje validaci prostřednictvím callbacku validation. Můžete vynutit povinná pole, minimální/maximální hodnoty, regex vzory a vlastní pravidla:

defineField({
  name: 'seoDescription',
  title: 'Meta Description',
  type: 'string',
  validation: (Rule) =>
    Rule.required()
      .min(145)
      .max(160)
      .warning('Meta description should be 145-160 characters'),
})

Vlastní typy bloků (Naše produkční příklady)

Zde se Sanity stává zajímavým a kde 0 ze 6 konkurenčních průvodců neukazuje žádný kód. V našem produkčním schématu definujeme pět vlastních typů bloků uvnitř pole body: block (standardní text), table, codeBlock, chartBlock a inlineImage.

Zde je naše definice codeBlock:

// schemas/objects/codeBlock.ts
import { defineType } from 'sanity'

export const codeBlock = defineType({
  name: 'codeBlock',
  title: 'Code Block',
  type: 'object',
  fields: [
    {
      name: 'language',
      title: 'Language',
      type: 'string',
      options: {
        list: [
          { title: 'JavaScript', value: 'javascript' },
          { title: 'TypeScript', value: 'typescript' },
          { title: 'Python', value: 'python' },
          { title: 'Bash', value: 'bash' },
          { title: 'JSON', value: 'json' },
          { title: 'GROQ', value: 'groq' },
        ],
      },
    },
    {
      name: 'code',
      title: 'Code',
      type: 'text',
    },
  ],
})

A zde je, jak pole body odkazuje na všechny naše vlastní typy dohromady:

// schemas/fields/body.ts
defineField({
  name: 'body',
  title: 'Body',
  type: 'array',
  of: [
    { type: 'block' },         // Standard Portable Text (paragraphs, headings, lists)
    { type: 'table' },         // @sanity/table plugin
    { type: 'codeBlock' },     // Our custom code block
    { type: 'chartBlock' },    // Data visualization (bar, line, pie)
    { type: 'inlineImage' },   // Images with alt text and captions
  ],
})

To dává našim editorům bohatý toolkit pro obsah, zatímco každý prvek zůstává typován a dotazovatelný. chartBlock není jen neprůhledné HTML embed, ale strukturovaná data s poli chartType, title, dataPoints a dataLabels. To má význam, když se snažíte vykreslit stejný obsah na webu, v e-mailu a na mobilu.

Osvědčené postupy pro organizaci schémat

Udržujte schémata modulární. My je rozdělujeme do souborů podle typu: schemas/documents/post.ts, schemas/objects/codeBlock.ts, schemas/objects/chartBlock.ts. Importujte je všechny v schemas/index.ts:

// schemas/index.ts
import { post } from './documents/post'
import { codeBlock } from './objects/codeBlock'
import { chartBlock } from './objects/chartBlock'
import { inlineImage } from './objects/inlineImage'

export const schemaTypes = [post, codeBlock, chartBlock, inlineImage]

Klíčovým poznatkem, který jsme získali prací se strukturovaným obsahem, je: vaše schéma JE vaším modelem obsahu. Pokud na něj budete myslet jako na inženýrství kontextu pro váš obsahový tým, učiníte lepší designová rozhodnutí. Každé pole, které přidáte, by mělo sloužit účelu, ať už pro editory, pro vykreslování nebo pro dotazování.

GROQ: Dotazovací jazyk Sanity

GROQ (Graph-Relational Object Queries) je open-source dotazovací jazyk Sanity pro filtrování, spojování a projekci JSON dokumentů. Základní syntaxe je *[filter]{projection}, vyberte všechny dokumenty odpovídající filtru a poté tvarujte výstup. Je stručnější než GraphQL pro dotazy specifické pro Sanity a podle našich zkušeností se rychleji učí.

Základní dotazy: Filtr a projekce

Nejjednodušší dotaz načte všechny dokumenty daného typu:

// Fetch all posts -- just title and slug
*[_type == "post"]{
  title,
  "slug": slug.current
}

// Filter by language, expand author reference
*[_type == "post" && language == "en"]{
  title,
  "slug": slug.current,
  "authorName": author->name,
  "authorImage": author->image,
  "categoryTitle": category->title,
  publishedAt
}

Operátor -> následuje reference. author->name znamená „následuj referenci autora a vrať pole name“. Žádné samostatné dotazy, žádné problémy N+1, žádné JOINy, je to vše jeden výraz.

Spoje, řazení a stránkování

Pro naše indexové stránky blogu potřebujeme seřazené, stránkované příspěvky s rozbalenými referencemi:

// Paginated posts with full metadata
*[_type == "post" && language == "en"] | order(publishedAt desc) [0...10] {
  title,
  "slug": slug.current,
  excerpt,
  publishedAt,
  readTime,
  "author": author->{name, image},
  "category": category->{title, "slug": slug.current},
  "coverImage": coverImage{
    "src": asset->url,
    alt
  }
}

[0...10] vám dá prvních 10 výsledků (indexováno od 0, exklusivní konec). | order(publishedAt desc) seřadí od nejnovějšího. Projekce tvaruje výstup tak, aby zahrnoval přesně to, co váš frontend potřebuje, nic víc.

Všechny tyto dotazy můžete interaktivně testovat pomocí pluginu Vision uvnitř Sanity Studio. Během vývoje je nenahraditelný. Pro více vzorů se podívejte na tahák GROQ.

GROQ vs GraphQL

Sanity podporuje jak GROQ, tak GraphQL. Kdy použít který?

GROQ je nativní jazyk Sanity. Zpracovává spoje, projekce a vypočítaná pole v jednom řetězci dotazu. Je optimalizován pro Content Lake.

GraphQL je dostupný po nasazení vašeho schématu (npx sanity@latest schema deploy). Použijte jej, když potřebujete standardizované nástroje, například pokud váš frontend již používá Apollo Client nebo pokud váš tým zná GraphQL, ale ne GROQ.

My používáme výhradně GROQ. Je expresivnější pro data Sanity a plugin Vision činí ladění dotazů triviálním.

Portable Text: Bohatý obsah udělaný správně

Portable Text je specifikace Sanity pro strukturovaný bohatý text. Místo ukládání obsahu jako HTML řetězců ukládá pole typovaných bloků, odstavců, nadpisů, obrázků, úryvků kódu, tabulek, každý jako JSON objekt. To činí obsah vykreslitelným v jakémkoli frameworku, na jakékoli platformě, v jakémkoli formátu.

Datová struktura

Zde je, jak vypadá odstavec a blok kódu jako JSON Portable Text:

[
  {
    "_type": "block",
    "_key": "a1b2c3",
    "style": "normal",
    "markDefs": [],
    "children": [
      {
        "_type": "span",
        "_key": "d4e5f6",
        "text": "Here's an example of our pipeline config:",
        "marks": []
      }
    ]
  },
  {
    "_type": "codeBlock",
    "_key": "g7h8i9",
    "language": "typescript",
    "code": "export default defineConfig({ ... })"
  }
]

Každý blok má _type a _key. Standardní textové bloky používají "block" s dětmi spans (které podporují značky jako tučné, kurzíva a odkazy). Vlastní bloky, jako náš codeBlock, chartBlock, table a inlineImage, používají svůj vlastní _type a nesou strukturovaná pole.

Proč na tom záleží? Protože HTML je formát vykreslování, nikoli formát ukládání. Pokud ve své databázi uložíte <h2>Název</h2><p>Nějaký <strong>text</strong></p>, uzamkli jste se do webového vykreslování. Nemůžete čistě extrahovat toto pro mobilní aplikaci, e-mailový newsletter, PDF nebo kontextové okno AI agenta. Portable Text odděluje obsah od prezentace. Specifikace Portable Text je open source, nejedná se o uzamčení u Sanity.

Vlastní bloky v produkci

Naše pipeline převádí Markdown na Portable Text pomocí Python skriptu (scripts/md_to_portable_text.py). Konvertor zpracovává standardní bloky plus naše čtyři vlastní typy:

• table, používá schéma pluginu @sanity/table. Řádky a buňky uloženy jako strukturovaná data.
• codeBlock, jazyk a kód jako samostatná pole, umožňující zvýraznění syntaxe při vykreslování.
• chartBlock, typ grafu, název, popisky os, názvy sérií a datové body jako strukturované JSON. Frontend je vykresluje pomocí Chart.js.
• inlineImage, alt text, zdroj a volitelný popisek jako samostatná pole.

Tato struktura znamená, že můžeme dotazovat všechny příklady kódu v našem blogu (*[body[]._type == "codeBlock"]), najít příspěvky s grafy nebo extrahovat všechny obrázky s chybějícím alt textem, vše prostřednictvím GROQ.

Vykreslování Portable Text

Na frontendu použijte @portabletext/react (nebo ekvivalenty pro Svelte/Vue). Registrujete vlastní komponenty pro každý typ bloku:

import { PortableText } from '@portabletext/react'

const components = {
  types: {
    codeBlock: ({ value }) => (
      <pre className={`language-${value.language}`}>
        <code>{value.code}</code>
      </pre>
    ),
    chartBlock: ({ value }) => <Chart data={value} />,
    inlineImage: ({ value }) => (
      <figure>
        <img src={value.src} alt={value.alt} />
        {value.caption && <figcaption>{value.caption}</figcaption>}
      </figure>
    ),
  },
}

// In your component:
<PortableText value={post.body} components={components} />

To je celá pipeline vykreslování. Komponenta PortableText zpracovává standardní bloky (odstavce, nadpisy, seznamy, značky) automaticky. Vlastní komponenty definujete pouze pro své vlastní typy.

Vícejazyčný obsah s Sanity CMS

Sanity podporuje vícejazyčný obsah prostřednictvím lokalizace na úrovni dokumentu (samostatné dokumenty pro každý jazyk propojené kanonickou referencí) nebo lokalizace na úrovni pole (přeložená pole v rámci jednoho dokumentu). Lokalizace na úrovni dokumentu funguje lépe pro SEO a publikování ve velkém měřítku, to je to, co používáme v naší 10jazykové pipeline.

Lokalizace na úrovni dokumentu vs. na úrovni pole

Zvolili jsme lokalizaci na úrovni dokumentu, protože každý překlad získá vlastní slug, vlastní URL a vlastní metadata. Turecká verze příspěvku o Supabase vs Firebase získá slug supabase-firebase-karsilastirma, správná turečtina, ne hack s parametrem URL.

Architektura naší 10jazykové pipeline

Zde je, jak funguje naše automatizovaná pipeline: napíšeme příspěvek v angličtině, poté jej přeložíme do 9 dalších jazyků (němčina, francouzština, nizozemština, španělština, turečtina, italština, švédština, norština, arabština). Každý překlad projde konverzí Markdown, generováním Portable Text a publikováním přes Sanity API.

Architektura vypadá takto:

1. Psaní, anglický Markdown s YAML frontmatter
2. Překlad, AI překlad do 9 jazyků (ověřeno pro úplnost a diakritiku)
3. Konverze, Python skript převede každý soubor .md na JSON Portable Text
4. Publikování, API volání do Sanity: vytvoření dokumentu, nahrání obrázků, patchování referencí

Každý dokument má pole language a referenci canonicalPost ukazující na anglický originál. Zde je dotaz GROQ pro načtení příspěvku a všech jeho překladů:

// Fetch a post and all its translations
*[_type == "post" && slug.current == "sanity-cms-guide" && language == "en"][0]{
  title,
  language,
  "translations": *[
    _type == "post" &&
    canonicalPost._ref == ^._id
  ]{
    title,
    language,
    "slug": slug.current
  }
}

Strana schématu je přímočará, pole language s enumem podporovaných jazyků:

defineField({
  name: 'language',
  title: 'Language',
  type: 'string',
  options: {
    list: [
      { title: 'English', value: 'en' },
      { title: 'German', value: 'de' },
      { title: 'French', value: 'fr' },
      { title: 'Dutch', value: 'nl' },
      { title: 'Spanish', value: 'es' },
      { title: 'Turkish', value: 'tr' },
      { title: 'Italian', value: 'it' },
      { title: 'Swedish', value: 'sv' },
      { title: 'Norwegian', value: 'no' },
      { title: 'Arabic', value: 'ar' },
    ],
  },
  validation: (Rule) => Rule.required(),
})

Jeden háček, který jsme se naučili těžkou cestou: nejprve publikujte anglický dokument, poté patchujte reference canonicalPost u překladů pomocí publikovaného ID dokumentu, ne prefixu drafts.. Sanity interně treatuje koncepty a publikované dokumenty jako samostatné entity.

Pro více detailů o tom, jak se tato pipeline připojuje k Model Context Protocol, viz další sekce.

Funkce AI v Sanity: MCP, Canvas a Kontext agenta

Sanity se позиционuje jako operační systém pro obsah éry AI. Klíčové funkce AI zahrnují MCP server pro čtení a zápis obsahu AI agenty, Canvas pro editaci asistovanou AI uvnitř Studia a Agent Context pro produkční AI agenty k dotazování na strukturovaný obsah s awareness schématu.

Integrace MCP serveru

Sanity MCP server umožňuje AI agentům, Claude Code, Cursor, Windsurf a dalším, programově interagovat s vaším pracovním prostorem Sanity. Agenti mohou číst schémata, provádět dotazy GROQ, vytvářet dokumenty a spravovat obsah bez vlastních API wrapperů.

Sanity MCP server používáme denně v naší obsahové pipeline. Naši AI agenti dotazují schéma, aby pochopili strukturu dokumentu, načítají existující příspěvky pro nalezení příležitostí k internímu linkování a publikují nové dokumenty. Protokol MCP dává agentům awareness schématu, vědí, jaká pole existují, jaké typy očekávají a jaká validační pravidla platí. Pokud budujete AI agenty pro business workflow, je to silný vzor.

Agent Context pro produkční AI

Agent Context je samostatná funkce pro AI integrace produkční kvality. Na rozdíl od MCP serveru (který je navržen pro vývojářské nástroje) poskytuje Agent Context read-only, scopeovaný přístup pro AI agenty, kteří potřebují dotazovat váš obsah za běhu, pomyslete chatboty, doporučovací engine nebo systémy personalizace obsahu.

Rozdíl matters: MCP je pro build-time a editorské workflow (nástroje pro vývoj aware schématu), zatímco Agent Context je pro runtime přístup k obsahu s řádnou autentizací a rate limitingem.

Strukturovaný obsah Sanity mu zde dává skutečnou výhodu. Web WordPress ukládá obsah jako HTML bloby, AI agent musí parsovat HTML, aby pochopil obsah. Sanity ukládá typované JSON dokumenty s definovanými schématy. Agent může dotazovat *[_type == "product" && category == "electronics"]{name, price, features} a dostat zpět čistá, strukturovaná data. Žádné scrapování, žádné parsování, žádné hádání.

Jak používáme Sanity v Techsy

Toto není hypotetická sekce. Provozujeme Sanity CMS na 4 produkčních webech, publikujeme ve 10 jazycích s automatizovanou pipeline, kterou jsme vybudovali během posledního roku. Zde je architektura.

Architektura naší obsahové pipeline

Pipeline jde od výzkumu k publikovanému příspěvku ve všech 10 jazycích:

1. Výzkum, analýza klíčových slov, identifikace mezer u konkurence, vzory SERP
2. Brief, strukturovaná specifikace psaní s pokyny pro sekce, počty slov, interní odkazy
3. Psaní, vytvoření anglického Markdownu s YAML frontmatter
4. Konverze, Python skript transformuje Markdown na JSON Portable Text s našimi 5 vlastními typy bloků
5. Publikování, API volání do Sanity: createOrReplace dokument, nahrání obrázků na CDN Sanity, patchování referencí autor/kategorie
6. Překlad, AI překlad do 9 jazyků, ověřeno pro úplnost
7. Publikování překladů, stejný flow konverze/publikování pro každý jazyk, s referencí canonicalPost patchovanou na anglický originál

Vlastní schéma podporuje typy block, table, codeBlock, chartBlock a inlineImage, všechny definované jako produkční objekty schématu Sanity s validačními pravidly. Mezi AI nástroji pro startupy, které jsme testovali, byla tato pipeline založená na Sanity nejspolehlivější pro strukturovaný obsah ve velkém měřítku.

Lekce z 400+ publikovaných kusů

Pár věcí, o kterých jsme si přáli, aby nám je někdo řekl:

Pořadí patchování referencí matters. Reference Sanity nemohou ukazovat na dokumenty, které ještě neexistují. Nejprve publikujte anglický příspěvek, poté vytvořte překlady s canonicalPost ukazující na publikované ID anglického dokumentu. Několikrát jsme to na začátku pokazili.

Nasazení schématu je na workspace. Pokud provozujete více projektů Sanity (my provozujeme 4), musíte nasadit schémata do každého zvlášť: npx sanity@latest schema deploy pro každou konfiguraci projektu.

Bezplatná verze je reálná. Dva z našich čtyř webů jsme měsíce provozovali na bezplatném plánu. 20 uživatelů, 500 tisíc API požadavků/měsíc, 100 tisíc CDN požadavků, to stačí na skutečný produkční web, ne jen na hračkový projekt.

Konverze Portable Text je úzké hrdlo. Markdown na Portable Text není triviální. Vnořené seznamy, tabulky uvnitř blockquotes, bloky kódu se speciálními znaky, edge cases všude. Naš konvertor skript jsme iterativně vylepšovali měsíce.

Potřebujete pomoc s nastavením Sanity pro váš projekt? Vybuildovali jsme vícejazyčné obsahové pipeline pro 4 produkční weby. Získejte bezplatnou konzultaci

Rozbor ceníku Sanity CMS

Sanity nabízí tři plány: Free (20 uživatelů, 500 tisíc API požadavků/měsíc), Growth (15 $/uživatel/měsíc s pokročilými rolemi a plánovanými koncepty) a Enterprise (vlastní ceny s SLA a compliance funkcemi). Bezplatná verze je nejštědřejší na trhu headless CMS.

Na bezplatné verzi provozujeme dva z našich webů, aniž bychom narazili na limity. Plán Growth za 15 $/uživatel/měsíc přidal přístup založený na rolích (důležité, jakmile jsme měli netechnické editory) a plánované publikování. Diváci jsou na Growth zdarma, což je hezký tah, nejste penalizováni za poskytnutí read přístupu stakeholderům.

Jak se to porovnává s konkurencí?

20-uživatelská bezplatná verze Sanity je výjimečná. Contentful vás limituje na 1 uživatele na free a skočí na 300 $/měsíc pro jejich Team plán. Pokud jste startup nebo malý tým, bezplatný plán Sanity vám umožní provozovat skutečné produkční workloady bez utrácení peněz.

Sanity také nabízí startup program, který kvalifikovaným startupům poskytuje jeden rok free přístupu k Growth. Stojí za to požádat, pokud splňujete podmínky.

Často kladené otázky

Co je Sanity CMS a jak funguje?

Sanity CMS je headless platforma pro obsah, která ukládá strukturované JSON dokumenty ve spravovaném backendu zvaném Content Lake. Obsah editujete prostřednictvím Sanity Studio (přizpůsobitelná React aplikace), dotazujete se na něj pomocí GROQ nebo GraphQL a vykreslujete jej v jakémkoli frontend frameworku. Obsah se synchronizuje v reálném čase napříč všemi připojenými klienty.

Je Sanity CMS zdarma?

Ano. Bezplatná verze Sanity zahrnuje 20 uživatelů, 500 tisíc API požadavků měsíčně a 100 tisíc CDN požadavků, což je nejštědřejší bezplatný plán mezi headless CMS platformami. Plán Growth stojí 15 $ za uživatele měsíčně a přidává přístup založený na rolích, plánované publikování a vyšší limity. Ceny Enterprise jsou vlastní.

Jaký je rozdíl mezi Sanity a Contentful?

Sanity používá schema-as-code (schémata žijí ve vašem codebase), GROQ pro dotazování a plně přizpůsobitelné open-source Studio. Contentful používá modelování obsahu založené na GUI, GraphQL a hostovaný editor s menší možností přizpůsobení. Bezplatná verze Sanity zahrnuje 20 uživatelů oproti 1 u Contentful. Contentful má větší marketplace pluginů.

Je Sanity CMS dobré pro začátečníky?

Sanity Studio je intuitivní pro content editory, zážitek z editace nevyžaduje žádné technické znalosti. Nastavení schémat však vyžaduje znalost JavaScriptu nebo TypeScriptu. Sanity poskytuje vynikající dokumentaci, šablony projektů a komunitní Slack s aktivní podporou. Začněte s npm create sanity@latest a šablonou blogu.

Mohu hostovat Sanity sám?

Sanity Studio je plně self-hostovatelné, protože jde o open-source React aplikaci. Můžete jej nasadit na Vercel, Netlify nebo jakéhokoli poskytovatele statického hostingu. Backend Content Lake je spravovaná služba, pro datovou vrstvu neexistuje možnost self-hostingu. Je to kompromis: získáte nulovou správu infrastruktury, ale žádnou kontrolu nad daty on-premises.

Jaký typ databáze Sanity používá?

Content Lake Sanity není tradiční SQL nebo NoSQL databáze. Je to spravované úložiště dokumentů, které ukládá obsah jako strukturované JSON s vrstvou dotazů GROQ na top. Neinteragujete přímo s underlying databází, interagujete prostřednictvím API Sanity. Dokumenty mají vestavěnou úplnou historii verzí a synchronizaci v reálném čase.

Je Sanity CMS open source?

Sanity Studio je open source pod licencí MIT, můžete jej forknout, přizpůsobit a self-hostovat. Backend Content Lake je proprietární SaaS. Specifikace dotazovacího jazyka GROQ je také open source, publikována na GitHubu. Specifikace Portable Text je rovněž open source, udržována na portabletext.org.

Co je Portable Text v Sanity?

Portable Text je specifikace Sanity pro strukturovaný bohatý text. Místo ukládání obsahu jako HTML řetězců reprezentuje odstavce, nadpisy, obrázky a vlastní bloky jako typované JSON objekty v poli. To činí obsah přenosným napříč frameworky a platformami. Můžete definovat vlastní typy bloků, jako jsou úryvky kódu, grafy a tabulky, s jejich vlastními strukturovanými poli.

Co je GROQ a jak se liší od GraphQL?

GROQ (Graph-Relational Object Queries) je nativní dotazovací jazyk Sanity. Jeho syntaxe, *[filter]{projection}, je stručnější než GraphQL pro data Sanity, s vestavěnou podporou pro spoje prostřednictvím operátoru -> a vypočítaných polí. GraphQL je také dostupné pro týmy, které preferují standardizované nástroje nebo již používají Apollo Client.

Jak Sanity zpracovává vícejazyčný obsah?

Sanity podporuje lokalizaci na úrovni dokumentu (samostatné dokumenty pro každý jazyk propojené kanonickými referencemi) a lokalizaci na úrovni pole (přeložená pole v rámci jednoho dokumentu). Lokalizace na úrovni dokumentu je lepší pro SEO, protože každý překlad získá vlastní URL a metadata. Používáme lokalizaci na úrovni dokumentu k publikování ve 10 jazycích s automatizovanými pipeline pro překlad a publikování.