@press2ai/engine 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@press2ai/engine",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Multi-tenant runtime + template contracts dla otwarty-* verticali. SSR na Cloudflare Workers, isomorphic renderer (SSG/browser w roadmapie).",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -11,7 +11,6 @@ export type {
   RenderRequest,
   RenderContext,
   RenderResult,
-  HeadMeta,
   EditorSchema,
   EditorField,
   EditorSection,

package/src/runtime/ssr.ts

@@ -29,6 +29,26 @@ export interface SSRWorkerOpts<C, T> {
   loadContent(host: string, env: unknown): Promise<C | null>;
   /** Override base URL (np. dla preview albo custom domains). */
   baseUrlFor?(host: string): string;
+  /**
+   * Optional KV cache rendered responses. Klucz: `{prefix}:{host}:{path}?{query}`.
+   * TTL bierze z `route.cacheControl` (`s-maxage=N`) albo `defaultTtlSec`.
+   * Cache miss trafia do D1+render, cache hit zwraca surowy body+headers
+   * **bez** uruchamiania `loadContent` ani `template.render` — czyli zero
+   * D1 query na hot path. Cachuje wyłącznie 200 OK.
+   *
+   * Świadomie poza cache'em: opcjonalność. KV ma free tier 1k writes/dzień,
+   * landing musi sam zdecydować czy włącza. Wbudowane endpointy
+   * (/sitemap.xml, /robots.txt, /feed.xml) **nie** używają tego cache'a —
+   * mają swój własny `cache-control` skierowany do CDN, a KV pisanie dla
+   * sitemap'u które trafia 1×/dobę z botów to czysty waste.
+   */
+  cache?: {
+    kv: KVNamespace;
+    /** Domyślny TTL gdy route nie podaje cacheControl. Default 300s. */
+    defaultTtlSec?: number;
+    /** Prefix klucza KV — typowo nazwa wertykalu. Default 'engine'. */
+    keyPrefix?: string;
+  };
 }
 
 export interface OtwartyWorker {
@@ -59,6 +79,18 @@ export function createSSRWorker<C, T>(opts: SSRWorkerOpts<C, T>): OtwartyWorker
         return handleFeed(opts, host, env, baseUrl);
       }
 
+      // KV cache lookup — kompletny bypass D1+render gdy hit. Tylko GET, tylko
+      // gdy cache skonfigurowany. Klucz zawiera host (multi-tenant) i query.
+      const cacheKey = opts.cache && request.method === 'GET'
+        ? buildCacheKey(opts.cache.keyPrefix ?? 'engine', host, url.pathname, url.searchParams)
+        : null;
+      if (cacheKey && opts.cache) {
+        const hit = await opts.cache.kv.get(cacheKey, 'json') as CachedRender | null;
+        if (hit) {
+          return new Response(hit.body, { status: hit.status, headers: hit.headers });
+        }
+      }
+
       // Standard render path
       const content = await opts.loadContent(host, env);
       if (content === null) {
@@ -100,14 +132,48 @@ export function createSSRWorker<C, T>(opts: SSRWorkerOpts<C, T>): OtwartyWorker
       // Nagłówki z RenderResult przesłaniają wszystko (template wie najlepiej)
       Object.assign(headers, result.headers ?? {});
 
-      return new Response(result.body, {
-        status: result.status ?? 200,
-        headers,
-      });
+      const status = result.status ?? 200;
+
+      // Cache write — tylko 200 OK (4xx/5xx nie chcemy cementować w KV).
+      if (cacheKey && opts.cache && status === 200) {
+        const ttl = parseSMaxAge(headers['cache-control']) ?? opts.cache.defaultTtlSec ?? 300;
+        if (ttl > 0) {
+          await opts.cache.kv.put(
+            cacheKey,
+            JSON.stringify({ body: result.body, status, headers } satisfies CachedRender),
+            { expirationTtl: ttl },
+          );
+        }
+      }
+
+      return new Response(result.body, { status, headers });
     },
   };
 }
 
+/* ─────────────── KV cache helpers ─────────────── */
+
+interface CachedRender {
+  body: string;
+  status: number;
+  headers: Record<string, string>;
+}
+
+function buildCacheKey(prefix: string, host: string, path: string, query: URLSearchParams): string {
+  // Sortowanie query żeby `?p=2&q=foo` i `?q=foo&p=2` były tym samym kluczem.
+  const pairs: Array<[string, string]> = [];
+  query.forEach((v, k) => { pairs.push([k, v]); });
+  pairs.sort(([a], [b]) => a.localeCompare(b));
+  const qs = pairs.map(([k, v]) => `${k}=${v}`).join('&');
+  return `${prefix}:render:${host}:${path}${qs ? '?' + qs : ''}`;
+}
+
+function parseSMaxAge(cacheControl: string | undefined): number | null {
+  if (!cacheControl) return null;
+  const m = cacheControl.match(/s-maxage=(\d+)/);
+  return m ? parseInt(m[1]!, 10) : null;
+}
+
 /* ─────────────── Wbudowane endpointy ─────────────── */
 
 async function handleSitemap<C, T>(

package/src/template-blog.ts

@@ -103,16 +103,14 @@ function renderIndex(req: RenderRequest<BlogContent>, ctx: RenderContext<BlogThe
     .map((p) => `<article><h2><a href="/blog/${ctx.theme.esc(p.slug)}">${ctx.theme.esc(p.title)}</a></h2><time>${ctx.theme.esc(p.pubDate)}</time>${p.excerpt ? `<p>${ctx.theme.esc(p.excerpt)}</p>` : ''}</article>`)
     .join('\n');
   return {
-    head: { title: content.brand.siteName, description: content.brand.description, canonical: `${ctx.baseUrl}/` },
     body: ctx.theme.layout({ title: content.brand.siteName, description: content.brand.description }, `<h1>${ctx.theme.esc(content.brand.siteName)}</h1>${items}`),
   };
 }
 
 function renderPost(req: RenderRequest<BlogContent>, ctx: RenderContext<BlogTheme>): RenderResult {
   const post = req.content.posts.find((p) => p.slug === req.params.slug);
-  if (!post) return { status: 404, head: { title: '404' }, body: ctx.theme.layout({ title: '404' }, '<h1>404</h1>') };
+  if (!post) return { status: 404, body: ctx.theme.layout({ title: '404' }, '<h1>404</h1>') };
   return {
-    head: { title: `${post.title} | ${req.content.brand.siteName}`, description: post.excerpt, canonical: `${ctx.baseUrl}/blog/${post.slug}` },
     body: ctx.theme.layout(
       { title: post.title, description: post.excerpt },
       `<article><h1>${ctx.theme.esc(post.title)}</h1><time>${ctx.theme.esc(post.pubDate)}</time>${ctx.theme.markdown(post.body)}</article>`,
@@ -128,5 +126,5 @@ function renderRssXml(req: RenderRequest<BlogContent>, ctx: RenderContext<BlogTh
     .map((i) => `<item><title>${ctx.theme.esc(i.title)}</title><link>${i.link}</link><guid>${i.guid}</guid><pubDate>${i.pubDate}</pubDate>${i.description ? `<description>${ctx.theme.esc(i.description)}</description>` : ''}</item>`)
     .join('');
   const xml = `<?xml version="1.0"?><rss version="2.0"><channel><title>${ctx.theme.esc(feed.title)}</title><link>${feed.link}</link><description>${ctx.theme.esc(feed.description)}</description>${items}</channel></rss>`;
-  return { headers: { 'content-type': 'application/rss+xml' }, head: { title: '' }, body: xml };
+  return { headers: { 'content-type': 'application/rss+xml' }, body: xml };
 }

package/src/template-trener.ts

@@ -232,12 +232,6 @@ function renderIndex(req: RenderRequest<TrenerContent>, ctx: RenderContext<Trene
   };
 
   return {
-    head: {
-      title: q ? `${q} — ${content.brand.siteName}` : content.brand.siteName,
-      description: content.brand.description,
-      canonical: `${ctx.baseUrl}/`,
-      jsonLd,
-    },
     body: t.layout({ title: content.brand.siteName, description: content.brand.description, jsonLd }, body),
   };
 }
@@ -247,7 +241,6 @@ function renderProfile(req: RenderRequest<TrenerContent>, ctx: RenderContext<Tre
   if (!profile) {
     return {
       status: 404,
-      head: { title: 'Nie znaleziono' },
       body: ctx.theme.layout({ title: 'Nie znaleziono' }, '<h1>404</h1><p>Brak takiego trenera.</p>'),
     };
   }
@@ -268,12 +261,6 @@ function renderProfile(req: RenderRequest<TrenerContent>, ctx: RenderContext<Tre
   };
 
   return {
-    head: {
-      title: `${fullName} — ${profile.city ?? ''} | ${req.content.brand.siteName}`,
-      description,
-      canonical: `${ctx.baseUrl}/${profile.slug}`,
-      jsonLd,
-    },
     body: t.layout(
       { title: `${fullName} | ${req.content.brand.siteName}`, description, jsonLd },
       t.profileArticle(profile),

package/src/types.ts

@@ -118,19 +118,14 @@ export interface RenderContext<T> {
 export interface RenderResult {
   status?: number;
   headers?: Record<string, string>;
-  head: HeadMeta;
   body: string;
 }
 
-export interface HeadMeta {
-  title: string;
-  description?: string;
-  canonical?: string;
-  og?: { image?: string; type?: string; url?: string };
-  jsonLd?: object | object[];
-  /** Surowy HTML do wstawienia w <head> (tylko gdy naprawdę trzeba). */
-  extra?: string;
-}
+// HeadMeta usunięte w v0.3.0 — engine nigdy nie odczytywał `RenderResult.head`,
+// bo SEO meta-tagi i tak idą do `body` przez `theme.layout()`. Dwa źródła prawdy
+// (head field vs head w body) były źródłem rozjazdów (np. `<title>` w body
+// różnił się od title w deklarowanym head). Templaty teraz mają jedno źródło —
+// to które naprawdę trafia do HTML.
 
 /* ─────────────── Editor (Faza 0) ─────────────── */
 

package/src/type-tests.ts

@@ -1,28 +0,0 @@
-/**
- * Compile-time type tests. Plik nigdy nie biegnie w runtime — istnieje tylko
- * po to żeby tsc krzyknął jeśli któryś referencyjny template przestanie
- * spełniać OtwartyTemplate. Drugi cel: pokazać że ten sam template wchodzi
- * jako input do wszystkich trzech trybów engine'u (SSR / SSG / Browser).
- */
-
-import type { OtwartyTemplate, PresenceTemplate } from './types';
-import { trenerTemplate, type TrenerContent, type TrenerTheme } from './template-trener';
-import { blogTemplate, type BlogContent, type BlogTheme } from './template-blog';
-import type { createSSRWorker } from './runtime/ssr';
-import type { createSSGBuild, createBrowserRenderer } from './engine-signature';
-
-// 1. Każdy template jest poprawnym OtwartyTemplate
-const _trener: OtwartyTemplate<TrenerContent, TrenerTheme> = trenerTemplate;
-const _blog: OtwartyTemplate<BlogContent, BlogTheme> = blogTemplate;
-
-// 2. Discriminator działa — TS narrowi 'const x = trenerTemplate' do PresenceTemplate
-//    nawet jeśli annotujemy szerzej. Wystarczy że union assignment kompiluje.
-const _presenceCheck: PresenceTemplate<TrenerContent, TrenerTheme> = trenerTemplate;
-
-// 3. Ten sam template jako input do wszystkich trzech trybów engine'u
-type _SSR = ReturnType<typeof createSSRWorker<TrenerContent, TrenerTheme>>;
-type _SSG = ReturnType<typeof createSSGBuild<TrenerContent, TrenerTheme>>;
-type _BROWSER = ReturnType<typeof createBrowserRenderer<TrenerContent, TrenerTheme>>;
-type _SSR_BLOG = ReturnType<typeof createSSRWorker<BlogContent, BlogTheme>>;
-
-export type { _SSR, _SSG, _BROWSER, _SSR_BLOG };