https://francl.digital/cs/blog/ Poznámky ze zakázek — weby, propojování systémů, AI. Proč jsem něco postavil takhle a co bych příště udělal jinak. Bez teorie a bez plánu vydávání. cs-CZ krystof@francl.digital (Kryštof Francl) https://francl.digital/cs/blog/proc-tento-web/ https://francl.digital/cs/blog/proc-tento-web/ Mon, 20 Apr 2026 00:00:00 GMT Mohl jsem si vystačit s LinkedIn vizitkou. Tady je pár důvodů, proč jsem místo toho postavil vlastní web na Cloudflare Workers. meta astro cloudflare portfolio https://francl.digital/cs/blog/raveo/ https://francl.digital/cs/blog/raveo/ Thu, 12 Mar 2026 00:00:00 GMT Každý web na zakázku začínal od nuly. Postavil jsem si proto vlastní základ — klient si obsah spravuje sám, není co udržovat na serveru a web běží rychle po celém světě. Cloudflare Astro PayloadCMS Workers edge {}); } return data; } ``` Klíčový detail je `fire-and-forget` zápis do KV. Odpověď uživateli nečeká na to, až se data zapíšou do cache. Zápis jde na pozadí. Na každý request se paralelně načtou čtyři věci: ```ts const [navigation, siteSettings, pagesData, postsData] = await Promise.all([ cachedFetch(fetcher, cmsUrl, '/api/globals/navigation?depth=1', cache), cachedFetch(fetcher, cmsUrl, '/api/globals/site-settings?depth=1', cache), cachedFetch(fetcher, cmsUrl, '/api/pages?depth=2&limit=100&where[status][equals]=published', cache), cachedFetch(fetcher, cmsUrl, '/api/posts?depth=2&limit=100&where[status][equals]=published', cache), ]); ``` `Promise.all` je důležitý — všechna čtyři volání jdou paralelně, ne za sebou. ## Revalidace obsahu KV cache má TTL pět minut. Ale co když klient uloží změnu a chce ji vidět okamžitě? Každá kolekce v CMS má `afterChange` hook. Když se obsah uloží, hook zavolá Web Worker a řekne mu, ať zneplatní cache: ```ts const revalidate = async () => { if (process.env.NODE_ENV === 'production') { // Service binding: CMS Worker volá Web Worker přímo await cfEnv.WEB.fetch( new Request('https://web/api/revalidate', { method: 'POST', headers: { 'x-revalidate-secret': cfEnv.REVALIDATE_SECRET ?? '' }, }), ); } else { await fetch(`${webUrl}/api/revalidate`, { method: 'POST', ... }); } }; export const revalidateAfterChange: CollectionAfterChangeHook = async ({ doc }) => { await revalidate(); return doc; }; ``` Po revalidaci KV cache vyprší a při dalším requestu se načtou čerstvá data z CMS. Žádný rebuild pipeline, žádné čekání na deploy. ## Lexical renderer: JSON do HTML bez JavaScriptu `PayloadCMS` ukládá obsah bohatého textu ve formátu `Lexical JSON` — stromová struktura uzlů. Hotové knihovny to řeší přes React a klientský JavaScript. Jenže Astro stránky jsou statické, klientský JavaScript nechci. Napsal jsem vlastní server-side renderer. Zajímavá část je formátování textu. Lexical ukládá formát jako bitový příznak — číslo, kde každý bit znamená jiný styl: ```ts function renderTextFormat(text: string, format: number): string { let result = escapeHtml(text); if (format & 16) result = `${result}`; // inline kód if (format & 1) result = `${result}`; // tučné if (format & 2) result = `${result}`; // kurzíva if (format & 8) result = `${result}`; // podtržení if (format & 4) result = `${result}`; // přeškrtnutí if (format & 32) result = `<sub>${result}</sub>`; // dolní index if (format & 64) result = `<sup>${result}</sup>`; // horní index } ``` Bitový AND (`&`) zkontroluje, jestli je daný bit nastavený. Text může být tučný a zároveň kurzíva — oba bity jsou nastavené zároveň. Renderer zpracovává celý strom rekurzivně: odstavce, nadpisy, citace, seznamy, checkboxy, odkazy, obrázky. Výstup je čisté HTML bez klientského JavaScriptu. ## Rate limiting na KV Rate limiter jsem nechtěl řešit přes externí službu. `KV` namespace pro cache je k dispozici, tak jsem ho použil i na rate limiting. Implementace je sliding window: pro každou IP adresu uchovává počet requestů a začátek časového okna: ```ts interface RateLimitEntry { count: number; windowStart: number; } ``` Klíčové rozhodnutí v návrhu: rate limiter **fails open** — pokud `KV` není dostupný, request projde. Alternativa by byla odmítnout request, ale výpadek KV by pak vyřadil celý web. Fail open je v tomhle případě správná volba. POST requesty jsou omezeny na 10 za minutu, API endpointy na 30. Odpověď vrací RFC standardní hlavičky `RateLimit-Remaining` a `Retry-After`. ## Kde to teď je a kam míří Na Raveu teď stavím web pro svoje skautské středisko Prácheň. Bude to první reálné nasazení stacku v produkci. Do budoucna mě zajímá integrace s `Medusa.js` jako transakčním backendem. Z Ravea by tak šlo stavět e-shopová řešení na zakázku: `PayloadCMS` na správu obsahu, `Medusa` na produkty a objednávky, `Astro` na frontend. Celé bez vlastního serveru, globálně distribuované, s obsahem, který si klient spravuje sám. Celý projekt je open source na [github.com/raveo-dev/raveo](https://github.com/raveo-dev/raveo).]]> https://francl.digital/cs/blog/esmm-validator/ https://francl.digital/cs/blog/esmm-validator/ Thu, 08 Jan 2026 00:00:00 GMT Překlep ve specifikaci se najde až u testera nebo u vývojáře v kódu, a to znamená vracet se a předělávat. Napsal jsem nástroj, který ji zkontroluje dřív — MCP server pro AI asistenta v editoru. MCP integrace validace AI banking ({ role: "user", content: { type: "text", text: idx === 0 ? block : `# CONTINUATION\n${block}`, }, })); const samplingResponse = await server.createMessage({ messages, systemPrompt, maxTokens: 16000, modelPreferences: { intelligencePriority: 0.9 }, }); ``` Každý blok je samostatná zpráva, druhý a další mají hlavičku `# CONTINUATION`, aby AI věděla, že jde o pokračující data. Systémový prompt definuje přesná pravidla validace. Výstup je markdown tabulka: ``` | index | file | sheet | row | column | raw_path | error_code | expected | ``` Pokud AI vrátí něco nepoužitelného nebo prázdnou odpověď, nástroj zahodí výsledek a vrátí prázdnou kostru. Falešné výsledky se nerozšíří dál. ## Co nefunguje a co řeším Bylo by neférové napsat jen to, co funguje. Největší praktický problém je kontextové okno. Při práci s větším počtem souborů nebo komplexnějšími `XSD` strukturami se kontext vyčerpá dřív, než AI dokončí validaci. Sampling se přeruší nebo vrátí nekompletní výsledek. Momentálně to řeším dělením na menší bloky, ale u opravdu velkých ESMM souborů to pořád naráží. Druhá věc: osm kroků za sebou, které musí uživatel ručně spouštět, je v praxi nepohodlné. Implementoval jsem proto jednodušší tříkrokové workflow, které celý průběh zkomprimuje a uživatel ho spustí jednou. Výsledek je stejný, práce navíc minimální. Třetí věc, tentokrát pozitivní objev: hodně záleží na modelu. `claude-sonnet-4-6` s Thinking režimem si poradí s věcmi, na kterých se jiné modely zaseknou. Konkrétně: když nástroj nenajde soubor kvůli nekonzistenci v názvu, model sám odhalí, kde je problém, doplní chybějící vstup a pokračuje do samplingové fáze bez zásahu uživatele. Tohle je rozdíl, který v praxi šetří čas. ## Kde to teď je Kolegové na integračním oddělení to začínají používat. Validaci spustí ještě předtím, než ESMM putuje do test analýzy — a chyby, které dřív vyplavaly až u testera nebo vývojáře, se zachytí tady. Projekt je interní a ještě žije. Ale princip je přenositelný: vezmi tabulkovou specifikaci, porovnej ji se skutečnými soubory, vrať, co nesedí. MCP k tomu dává hezkou strukturu: tools pro akce, resources pro znalosti, prompts pro workflow, sampling pro AI. Čtyři stavební bloky a z nich jde poskládat nástroj, který se chová jako plnohodnotný účastník vývojového prostředí, ne jako izolovaný skript.]]>