@press2ai/engine 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@press2ai/engine",
-  "version": "0.2.0",
+  "version": "0.4.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/ceidg-vertical.ts

@@ -22,9 +22,10 @@
  *     i — fix względem starego trener-landinga — `cities` query też filtruje
  *     po kategorii (wcześniej trener pokazywał miasta z całej tabeli leads,
  *     mieszając wszystkie wertykale).
- *   - Opt-out jest **globalny** — UPDATE leads bez filtra category. RODO
- *     sprzeciw to usunięcie danych osobowych, nie selektywne ukrycie w jednej
- *     kategorii. Komentarz przeniesiony z terapeuta-landinga.
+ *   - Opt-out jest **globalny** i **hard delete**: DELETE FROM leads + wpis
+ *     w `opted_out_nips` (blacklist NIP-ów żeby sync nie wprowadził z powrotem).
+ *     RODO art. 17 — usunięcie danych osobowych, nie soft flag. Z karty profilu
+ *     przez slug (jeden klik), bez formularza NIP.
  *
  * Hono jest peer dependency (każdy wertykal i tak go ma). Engine core nie
  * importuje Hono — tylko ten subpath go używa.
@@ -53,7 +54,6 @@ export type CeidgLead = {
   claimed: number;
   external_site_url: string | null;
   fetched_at: number;
-  opted_out_at: number | null;
 };
 
 export type CeidgBindings = { DB: D1Database; CACHE: KVNamespace };
@@ -108,17 +108,15 @@ export function createVerticalApp(config: VerticalConfig): Hono<{ Bindings: Ceid
   // ─────────── SQL ───────────
   // EXISTS subselect zamiast JOIN: lead z N PKDs nie multiplikuje wierszy.
   // (SELECT pkd ... LIMIT 1) wybiera jeden PKD per lead — wystarczy do
-  // pkdToJobTitle. To jest świadomy uproszczenie: lead z mieszanymi PKDs
-  // (np. fizjoterapia + psychologia) dostanie tylko jeden label.
+  // pkdToJobTitle. Świadome uproszczenie: lead z mieszanymi PKDs dostanie
+  // jeden label. Filtr opted-out zbędny — opt-out to hard delete (0010).
   const leadsQuery = `
     SELECT l.nip, l.first_name, l.last_name, c.name as city,
            l.company_name, l.slug, l.claimed, l.external_site_url, l.fetched_at,
-           l.opted_out_at,
            (SELECT pkd FROM lead_pkd WHERE nip = l.nip LIMIT 1) as pkd
     FROM leads l
     LEFT JOIN cities c ON l.city_id = c.id
-    WHERE l.opted_out_at IS NULL
-      AND EXISTS (SELECT 1 FROM lead_categories WHERE lead_nip = l.nip AND category = ?)`;
+    WHERE EXISTS (SELECT 1 FROM lead_categories WHERE lead_nip = l.nip AND category = ?)`;
 
   // Cities query filtruje po kategorii — fix względem starego trener landinga
   // który pokazywał miasta z całej tabeli leads (mieszane wertykale).
@@ -127,7 +125,6 @@ export function createVerticalApp(config: VerticalConfig): Hono<{ Bindings: Ceid
     FROM leads l
     JOIN cities c ON l.city_id = c.id
     INNER JOIN lead_categories lc ON l.nip = lc.lead_nip AND lc.category = ?
-    WHERE l.opted_out_at IS NULL
     GROUP BY c.name ORDER BY count DESC LIMIT 8`;
 
   // ─────────── Content loader ───────────
@@ -261,10 +258,15 @@ export function createVerticalApp(config: VerticalConfig): Hono<{ Bindings: Ceid
   }
   app.get('/opt-out', (c) => c.html(renderStatic(pages.optOutForm)));
 
+  // One-click opt-out: przycisk na karcie profilu POST-uje slug. Hard delete
+  // z `leads` (cascade do `lead_pkd`/`lead_categories`) + insert do blacklisty
+  // `opted_out_nips` żeby sync nie wprowadził NIP-a z powrotem. Rate limit
+  // 5/h/IP przeciw abuse — slug jest publiczny, ktokolwiek może nukeować,
+  // ale katalog to publiczne wizytówki z CEIDG, nie konta.
   app.post('/opt-out', async (c) => {
     const form = await c.req.formData();
-    const nip = String(form.get('nip') ?? '').replace(/\D/g, '');
-    if (nip.length !== 10) return c.text('Nieprawidłowy NIP', 400);
+    const slug = String(form.get('slug') ?? '').trim();
+    if (!slug) return c.text('Brak slug', 400);
 
     const ip = c.req.header('cf-connecting-ip') ?? '0.0.0.0';
     const rlKey = `vertical:${category}:rl:optout:${ip}`;
@@ -272,16 +274,21 @@ export function createVerticalApp(config: VerticalConfig): Hono<{ Bindings: Ceid
     if (rlVal >= OPTOUT_LIMIT) return c.text('Zbyt wiele prób. Spróbuj ponownie za godzinę.', 429);
     await c.env.CACHE.put(rlKey, String(rlVal + 1), { expirationTtl: OPTOUT_WINDOW_SEC });
 
-    // Opt-out jest GLOBALNY — usuwa też z innych wertykali. RODO sprzeciw to
-    // usunięcie danych osobowych, nie selektywne ukrycie w jednej kategorii.
-    const res = await c.env.DB
-      .prepare(
-        'UPDATE leads SET opted_out_at = ?, opted_out_ip = ?, opted_out_ua = ? WHERE nip = ? AND opted_out_at IS NULL',
-      )
-      .bind(Math.floor(Date.now() / 1000), ip, c.req.header('user-agent') ?? '', nip)
-      .run();
+    const row = await c.env.DB
+      .prepare('SELECT nip FROM leads WHERE slug = ?')
+      .bind(slug)
+      .first<{ nip: string }>();
+    if (!row) return c.text('Nie znaleziono wpisu', 404);
+
+    const now = Math.floor(Date.now() / 1000);
+    const ipHash = await sha256Hex(ip + ':' + slug);
+    await c.env.DB.batch([
+      c.env.DB.prepare('INSERT OR IGNORE INTO opted_out_nips (nip, opted_out_at, ip_hash) VALUES (?, ?, ?)').bind(row.nip, now, ipHash),
+      c.env.DB.prepare('DELETE FROM lead_categories WHERE lead_nip = ?').bind(row.nip),
+      c.env.DB.prepare('DELETE FROM lead_pkd WHERE nip = ?').bind(row.nip),
+      c.env.DB.prepare('DELETE FROM leads WHERE nip = ?').bind(row.nip),
+    ]);
 
-    if (!res.meta.changes) return c.text('Nie znaleziono wpisu', 404);
     return c.html(renderStatic(pages.optOutDone));
   });
 
@@ -303,3 +310,8 @@ export function createVerticalApp(config: VerticalConfig): Hono<{ Bindings: Ceid
 
   return app;
 }
+
+async function sha256Hex(input: string): Promise<string> {
+  const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(input));
+  return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, '0')).join('');
+}

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 };