@press2ai/engine 0.5.1 → 1.0.0

package/src/runtime/ssr.ts

@@ -1,298 +0,0 @@
-/**
- * createSSRWorker — Faza 0 multi-tenant runtime na CF Worker.
- *
- * Bierze OtwartyTemplate + theme + content loader. Per request:
- *   1. Parsuje URL → host, path, query
- *   2. Obsługuje wbudowane endpointy: /sitemap.xml, /robots.txt, /feed.xml
- *   3. Ładuje content przez loadContent(host, env) — multi-tenancy hook
- *   4. Matchuje path do template.routes() → wyciąga params
- *   5. Wywołuje template.render(req, ctx) — czystą funkcję
- *   6. Zwraca Response z body + nagłówkami z RenderResult
- *
- * Mutacje (POST/PUT/DELETE) NIE należą do engine v0.1 — landing wrapper
- * trzyma własne handlery dla opt-out, claim, edycji. Engine jest GET-only.
- */
-
-import type {
-  OtwartyTemplate,
-  RouteDescriptor,
-  RenderRequest,
-  RenderContext,
-  SitemapEntry,
-  RssFeed,
-} from '../types';
-
-export interface SSRWorkerOpts<C, T> {
-  template: OtwartyTemplate<C, T>;
-  theme: T;
-  /** Resolver host → tenant content. Engine cache'uje po stronie KV jeśli podany. */
-  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 {
-  fetch(request: Request, env: unknown, ctx?: unknown): Promise<Response>;
-}
-
-export function createSSRWorker<C, T>(opts: SSRWorkerOpts<C, T>): OtwartyWorker {
-  return {
-    async fetch(request, env): Promise<Response> {
-      // Engine obsługuje wyłącznie GET; mutacje są poza zakresem.
-      if (request.method !== 'GET' && request.method !== 'HEAD') {
-        return new Response('Method not allowed', { status: 405 });
-      }
-
-      const url = new URL(request.url);
-      const host = url.host;
-      const baseUrl = opts.baseUrlFor?.(host) ?? `${url.protocol}//${host}`;
-
-      // Wbudowane endpointy obsługiwane przez engine bezpośrednio
-      // (nie wymagają pełnego renderera, biorą dane z metod templatu).
-      if (url.pathname === '/sitemap.xml') {
-        return handleSitemap(opts, host, env, baseUrl);
-      }
-      if (url.pathname === '/robots.txt') {
-        return handleRobots(opts, host, env);
-      }
-      if (url.pathname === '/feed.xml' || url.pathname === '/rss.xml') {
-        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) {
-        return new Response('Not found', { status: 404 });
-      }
-
-      const routes = opts.template.routes(content);
-      const match = matchRoute(url.pathname, routes);
-      if (!match) {
-        return new Response('Not found', { status: 404 });
-      }
-
-      const query: Record<string, string> = {};
-      url.searchParams.forEach((v, k) => { query[k] = v; });
-
-      const req: RenderRequest<C> = {
-        path: url.pathname,
-        params: match.params,
-        query,
-        content,
-      };
-
-      const ctx: RenderContext<T> = {
-        baseUrl,
-        theme: opts.theme,
-        locale: opts.template.meta.locale,
-        mode: 'ssr',
-      };
-
-      const result = opts.template.render(req, ctx);
-
-      const headers: Record<string, string> = {
-        'content-type': 'text/html; charset=utf-8',
-      };
-      // Cache-Control z route descriptor (jeśli podany) — pozwala CDN cachować
-      if (match.route.cacheControl) {
-        headers['cache-control'] = match.route.cacheControl;
-      }
-      // Nagłówki z RenderResult przesłaniają wszystko (template wie najlepiej)
-      Object.assign(headers, result.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>(
-  opts: SSRWorkerOpts<C, T>,
-  host: string,
-  env: unknown,
-  baseUrl: string,
-): Promise<Response> {
-  const content = await opts.loadContent(host, env);
-  if (content === null) return new Response('Not found', { status: 404 });
-  const entries = opts.template.sitemap(content, baseUrl);
-  return new Response(renderSitemapXml(entries), {
-    headers: {
-      'content-type': 'application/xml; charset=utf-8',
-      'cache-control': 'public, s-maxage=86400',
-    },
-  });
-}
-
-async function handleRobots<C, T>(
-  opts: SSRWorkerOpts<C, T>,
-  host: string,
-  env: unknown,
-): Promise<Response> {
-  if (!opts.template.robots) {
-    return new Response('User-agent: *\nAllow: /\n', { headers: { 'content-type': 'text/plain' } });
-  }
-  const content = await opts.loadContent(host, env);
-  if (content === null) return new Response('Not found', { status: 404 });
-  return new Response(opts.template.robots(content), {
-    headers: { 'content-type': 'text/plain; charset=utf-8' },
-  });
-}
-
-async function handleFeed<C, T>(
-  opts: SSRWorkerOpts<C, T>,
-  host: string,
-  env: unknown,
-  baseUrl: string,
-): Promise<Response> {
-  if (!opts.template.feed) return new Response('Not found', { status: 404 });
-  const content = await opts.loadContent(host, env);
-  if (content === null) return new Response('Not found', { status: 404 });
-  const feed = opts.template.feed(content, baseUrl);
-  if (!feed) return new Response('Not found', { status: 404 });
-  return new Response(renderRssXml(feed), {
-    headers: {
-      'content-type': 'application/rss+xml; charset=utf-8',
-      'cache-control': 'public, s-maxage=3600',
-    },
-  });
-}
-
-/* ─────────────── Routing ─────────────── */
-
-interface RouteMatch<C> {
-  route: RouteDescriptor<C>;
-  params: Record<string, string>;
-}
-
-function matchRoute<C>(pathname: string, routes: RouteDescriptor<C>[]): RouteMatch<C> | null {
-  // Statyczne routes (bez :param) mają wyższy priorytet niż dynamiczne.
-  // Bez tego /sitemap.xml byłoby przechwycone przez /:slug.
-  const sorted = [...routes].sort((a, b) => {
-    const aDyn = a.path.includes(':');
-    const bDyn = b.path.includes(':');
-    if (aDyn === bDyn) return 0;
-    return aDyn ? 1 : -1;
-  });
-  for (const route of sorted) {
-    const params = matchPath(pathname, route.path);
-    if (params) return { route, params };
-  }
-  return null;
-}
-
-function matchPath(pathname: string, pattern: string): Record<string, string> | null {
-  const patternParts = pattern.split('/').filter(Boolean);
-  const pathParts = pathname.split('/').filter(Boolean);
-  if (patternParts.length !== pathParts.length) return null;
-
-  const params: Record<string, string> = {};
-  for (let i = 0; i < patternParts.length; i++) {
-    const pp = patternParts[i]!;
-    const ap = pathParts[i]!;
-    if (pp.startsWith(':')) {
-      params[pp.slice(1)] = decodeURIComponent(ap);
-    } else if (pp !== ap) {
-      return null;
-    }
-  }
-  return params;
-}
-
-/* ─────────────── XML helpers ─────────────── */
-
-function renderSitemapXml(entries: SitemapEntry[]): string {
-  const items = entries
-    .map((e) => {
-      const lastmod = e.lastmod ? `<lastmod>${e.lastmod}</lastmod>` : '';
-      const changefreq = e.changefreq ? `<changefreq>${e.changefreq}</changefreq>` : '';
-      const priority = e.priority !== undefined ? `<priority>${e.priority}</priority>` : '';
-      return `  <url><loc>${escapeXml(e.loc)}</loc>${lastmod}${changefreq}${priority}</url>`;
-    })
-    .join('\n');
-  return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${items}\n</urlset>`;
-}
-
-function renderRssXml(feed: RssFeed): string {
-  const items = feed.items
-    .map((i) => {
-      const desc = i.description ? `<description>${escapeXml(i.description)}</description>` : '';
-      const ce = i.content ? `<content:encoded><![CDATA[${i.content}]]></content:encoded>` : '';
-      return `<item><title>${escapeXml(i.title)}</title><link>${escapeXml(i.link)}</link><guid>${escapeXml(i.guid)}</guid><pubDate>${i.pubDate}</pubDate>${desc}${ce}</item>`;
-    })
-    .join('\n');
-  return `<?xml version="1.0" encoding="UTF-8"?>\n<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">\n<channel>\n<title>${escapeXml(feed.title)}</title>\n<link>${escapeXml(feed.link)}</link>\n<description>${escapeXml(feed.description)}</description>\n${items}\n</channel>\n</rss>`;
-}
-
-function escapeXml(s: string): string {
-  return s.replace(/[<>&"']/g, (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;', "'": '&apos;' })[c]!);
-}

package/src/template-blog.ts

@@ -1,130 +0,0 @@
-/**
- * template-blog — drugi referencyjny PresenceTemplate.
- * Jego ROLĄ jest udowodnić że abstrakcja przeżywa radikalnie inny kształt
- * niż katalog wizytówek: enumeracja postów per :slug, RSS feed, brak
- * data sources (treść w pełni manualna). Render jest minimalistyczny —
- * theme contract zostawiamy płytki, bo blog może działać na dowolnym
- * theme który ma `layout` + funkcję renderującą markdown body.
- */
-
-import { z } from 'zod';
-import type { PresenceTemplate, RenderRequest, RenderContext, RenderResult, RssFeed } from './types';
-
-export interface BlogTheme {
-  layout(props: { title: string; description?: string; jsonLd?: object }, body: string): string;
-  /** Zamienia markdown na HTML — implementacja po stronie theme. */
-  markdown(md: string): string;
-  esc(s: string): string;
-}
-
-const postSchema = z.object({
-  slug: z.string(),
-  title: z.string(),
-  pubDate: z.string(), // ISO 8601
-  author: z.string().optional(),
-  excerpt: z.string().optional(),
-  body: z.string(), // markdown
-});
-
-const blogContentSchema = z.object({
-  brand: z.object({ siteName: z.string(), description: z.string(), authorEmail: z.string().email().optional() }),
-  posts: z.array(postSchema).default([]),
-});
-
-export type BlogPost = z.infer<typeof postSchema>;
-export type BlogContent = z.infer<typeof blogContentSchema>;
-
-export const blogTemplate: PresenceTemplate<BlogContent, BlogTheme> = {
-  kind: 'presence',
-  id: 'blog',
-  name: 'Otwarty Blog',
-  version: '1.0.0',
-  schema: blogContentSchema,
-  defaultContent: {
-    brand: { siteName: 'Mój blog', description: 'Notatki, eseje, myśli.' },
-    posts: [],
-  },
-  editor: {
-    fields: [
-      { key: 'brand.siteName', label: 'Tytuł bloga', type: 'text', required: true },
-      { key: 'brand.description', label: 'Opis bloga', type: 'textarea', required: true },
-      {
-        key: 'posts',
-        label: 'Posty',
-        type: 'array',
-        itemSchema: [
-          { key: 'title', label: 'Tytuł', type: 'text', required: true },
-          { key: 'slug', label: 'Slug URL', type: 'text', required: true },
-          { key: 'pubDate', label: 'Data publikacji', type: 'date', required: true },
-          { key: 'excerpt', label: 'Zajawka', type: 'textarea' },
-          { key: 'body', label: 'Treść (markdown)', type: 'textarea', required: true },
-        ],
-      },
-    ],
-  },
-  routes(content) {
-    return [
-      { path: '/' },
-      { path: '/blog/:slug', enumerate: () => content.posts.map((p) => ({ slug: p.slug })) },
-      { path: '/rss.xml' },
-    ];
-  },
-  render(req, ctx) {
-    if (req.path === '/rss.xml') return renderRssXml(req, ctx);
-    if (req.params.slug) return renderPost(req, ctx);
-    return renderIndex(req, ctx);
-  },
-  sitemap(content, baseUrl) {
-    return [
-      { loc: `${baseUrl}/`, priority: 1.0, changefreq: 'weekly' },
-      ...content.posts.map((p) => ({ loc: `${baseUrl}/blog/${p.slug}`, lastmod: p.pubDate, priority: 0.7 })),
-    ];
-  },
-  feed(content, baseUrl): RssFeed {
-    return {
-      title: content.brand.siteName,
-      link: baseUrl,
-      description: content.brand.description,
-      items: content.posts.map((p) => ({
-        title: p.title,
-        link: `${baseUrl}/blog/${p.slug}`,
-        guid: `${baseUrl}/blog/${p.slug}`,
-        pubDate: p.pubDate,
-        description: p.excerpt,
-      })),
-    };
-  },
-  meta: { locale: 'pl-PL', description: 'Personal blog', suggestedTheme: 'specialist-glossy', tags: ['blog', 'markdown'] },
-};
-
-function renderIndex(req: RenderRequest<BlogContent>, ctx: RenderContext<BlogTheme>): RenderResult {
-  const { content } = req;
-  const items = content.posts
-    .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 {
-    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, body: ctx.theme.layout({ title: '404' }, '<h1>404</h1>') };
-  return {
-    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>`,
-    ),
-  };
-}
-
-function renderRssXml(req: RenderRequest<BlogContent>, ctx: RenderContext<BlogTheme>): RenderResult {
-  // Engine zazwyczaj wywoła template.feed() i sam zbuduje XML — to fallback
-  // dla prostej ścieżki SSR gdzie chcemy odpowiedzieć bez warstwy engine'u.
-  const feed = blogTemplate.feed!(req.content, ctx.baseUrl)!;
-  const items = feed.items
-    .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' }, body: xml };
-}