@tekki-forge/runtime-api 0.1.0 → 0.3.0

package/dist/site.js

@@ -0,0 +1,1413 @@
+import { randomBytes } from "node:crypto";
+import { buildSiteChrome, checkSiteSection, contentHash, defaultDataFields, isUploadedImage, PAGE_TEMPLATE_NAMES, POST_KINDS, sectionDefaults, sitePathProblem, templateContext, templatePage, validHref, validImage, } from "@tekki-forge/compiler";
+import { BadRequestException, ConflictException, ForbiddenException, HttpException, HttpStatus, Logger, NotFoundException, ServiceUnavailableException, UnauthorizedException } from "@nestjs/common";
+import { resolveTokens } from "./dashboard.js";
+import { parseListQuery, parseSort, QueryError } from "./query.js";
+import { relationInclude } from "./serialize.js";
+// ─── Access ──────────────────────────────────────────────────────────────────────────────────
+/** Global user roles of the caller (the `role` column, comma-separated), as the admin pages use them. */
+const globalRoles = (ctx) => (ctx.user?.role ?? "").split(",").map((r) => r.trim()).filter(Boolean);
+/** A signed-in person (never an API key) whose global roles include one of `site.editors`. */
+export function canEditSite(app, ctx) {
+    if (!app.site || ctx.apiKey || !ctx.principal || !ctx.user)
+        return false;
+    const editors = app.site.editors.length ? app.site.editors : ["admin"];
+    return globalRoles(ctx).some((r) => editors.includes(r));
+}
+/** Visitors: what the website shows is computed as nobody in particular. */
+const ANONYMOUS = { principal: null, user: null, session: null };
+const invalid = (issues) => new BadRequestException({ statusCode: 400, error: "Bad Request", message: "Validation failed", issues });
+const isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const iso = (d) => (d ? new Date(d).toISOString() : null);
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const SLUG = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const MAX_PAGE_SECTIONS = 40;
+// ─── Tables missing (schema not migrated yet) ────────────────────────────────────────────────
+const logger = new Logger("ForgeSite");
+let warnedMissing = false;
+/** Prisma "table/column does not exist" (P2021/P2022), or a client generated before the site models. */
+export function siteTablesMissing(e) {
+    if (e instanceof SiteTablesMissing)
+        return true;
+    const err = e;
+    if (err?.code === "P2021" || err?.code === "P2022")
+        return true;
+    const message = err?.message ?? "";
+    return /does not exist/.test(message) && /site_(pages|sections|posts)|contact_messages|newsletter_subscribers/.test(message);
+}
+class SiteTablesMissing extends Error {
+    constructor() {
+        super("The Prisma client has no site models");
+    }
+}
+function warnMissing() {
+    if (warnedMissing)
+        return;
+    warnedMissing = true;
+    logger.warn("The website tables are missing — run `forge db migrate` (until then the site is shown straight from forge.config.ts and cannot be edited)");
+}
+const MIGRATE = "The website tables are missing — run forge db migrate";
+/**
+ * What to do with a row that comes from the config and is still in it:
+ * - keep: nothing changed since the last sync (or the conflict is already flagged);
+ * - apply: the config changed and nobody edited the row in the admin → take the config version;
+ * - conflict: both changed (or the admin deleted it) → keep the admin version, flag it;
+ * - resolve: the config went back to the version last applied → the conflict is gone.
+ */
+export function syncDecision(row, hash) {
+    if (row.configHash === hash)
+        return row.conflict ? "resolve" : "keep";
+    if (row.edited || row.removed)
+        return row.conflict ? "keep" : "conflict";
+    return "apply";
+}
+/** The page columns a config page sets. */
+export function configPageFields(p) {
+    return { title: p.title, path: p.path, template: p.template ?? null, seo: p.seo, nav: p.nav, redirect: p.redirect ?? null, status: p.status };
+}
+const configSectionFields = (s) => ({ type: s.type, variant: s.variant, hidden: s.hidden, props: s.props });
+function freePath(path, taken) {
+    const base = `${path === "/" ? "/home" : path}-config`;
+    let candidate = base;
+    for (let n = 2; taken.has(candidate); n++)
+        candidate = `${base}-${n}`;
+    return candidate;
+}
+/**
+ * Pure part of the sync: compare the config (SiteIR) with the stored pages and list the writes to make.
+ * Admin work always wins over the config; conflicts are flagged, never overwritten.
+ */
+export function planSiteSync(site, rows, now = new Date()) {
+    const ops = [];
+    const report = { created: 0, updated: 0, conflicts: 0, removed: 0 };
+    const inConfig = new Set(site.pages.map((p) => p.key));
+    // Paths in use (unique column), kept current as the plan moves pages around.
+    const paths = new Map(rows.map((r) => [r.path, r.id]));
+    // Config pages that left the config: deleted, unless someone worked on them in the admin.
+    for (const row of rows) {
+        if (row.origin !== "config" || (row.key !== null && inConfig.has(row.key)))
+            continue;
+        const adminWork = row.edited || row.sections.some((s) => !s.removed && (s.origin !== "config" || s.edited));
+        if (!adminWork) {
+            ops.push({ op: "deletePage", id: row.id });
+            paths.delete(row.path);
+            report.removed++;
+            continue;
+        }
+        ops.push({ op: "updatePage", id: row.id, data: { origin: "admin", key: null, configHash: null, conflict: false } });
+        report.updated++;
+        for (const s of row.sections) {
+            if (s.removed) {
+                ops.push({ op: "deleteSection", id: s.id });
+                report.removed++;
+            }
+            else if (s.origin === "config")
+                ops.push({ op: "updateSection", id: s.id, data: { origin: "admin", configHash: null, conflict: false } });
+        }
+    }
+    const byKey = new Map(rows.filter((r) => r.origin === "config" && r.key !== null).map((r) => [r.key, r]));
+    site.pages.forEach((p, index) => {
+        const row = byKey.get(p.key);
+        if (!row) {
+            // An admin page already has this path: the config page comes in as a draft beside it, flagged.
+            const collision = paths.has(p.path);
+            const path = collision ? freePath(p.path, paths) : p.path;
+            const status = collision ? "draft" : p.status;
+            paths.set(path, `new:${p.key}`);
+            const { nav, ...fields } = configPageFields(p);
+            ops.push({
+                op: "createPage",
+                data: { ...fields, ...(nav !== null ? { nav } : {}), key: p.key, path, status, origin: "config", configHash: p.hash, conflict: collision, position: index, publishedAt: status === "published" ? now : null },
+                sections: p.sections.map((s, j) => ({ key: s.key, ...configSectionFields(s), origin: "config", configHash: s.hash, position: j })),
+            });
+            report.created += 1 + p.sections.length;
+            if (collision)
+                report.conflicts++;
+            return;
+        }
+        const page = {};
+        const decision = syncDecision(row, p.hash);
+        if (decision === "apply") {
+            const owner = paths.get(p.path);
+            if (owner !== undefined && owner !== row.id) {
+                // The new path belongs to another page: keep this one as it is and let the admin sort it out.
+                if (!row.conflict) {
+                    page.conflict = true;
+                    report.conflicts++;
+                }
+            }
+            else {
+                paths.delete(row.path);
+                paths.set(p.path, row.id);
+                Object.assign(page, configPageFields(p), { configHash: p.hash });
+                if (p.status === "published" && !row.publishedAt)
+                    page.publishedAt = now;
+                report.updated++;
+            }
+        }
+        else if (decision === "conflict") {
+            page.conflict = true;
+            report.conflicts++;
+        }
+        else if (decision === "resolve")
+            page.conflict = false;
+        if (row.position !== index)
+            page.position = index;
+        if (Object.keys(page).length)
+            ops.push({ op: "updatePage", id: row.id, data: page });
+        const declared = new Map(p.sections.map((s) => [s.key, s]));
+        const stored = new Map(row.sections.map((s) => [s.key, s]));
+        for (const s of row.sections) {
+            if (s.origin !== "config" || declared.has(s.key))
+                continue;
+            if (s.edited && !s.removed) {
+                ops.push({ op: "updateSection", id: s.id, data: { origin: "admin", configHash: null, conflict: false } });
+                report.updated++;
+            }
+            else {
+                ops.push({ op: "deleteSection", id: s.id });
+                report.removed++;
+            }
+        }
+        // Reordered in the admin: admin positions stay, new config sections go to the end.
+        let next = Math.max(-1, ...row.sections.map((s) => s.position)) + 1;
+        p.sections.forEach((s, j) => {
+            const existing = stored.get(s.key);
+            const position = row.orderEdited ? undefined : j;
+            if (!existing) {
+                ops.push({ op: "createSection", data: { pageId: row.id, key: s.key, ...configSectionFields(s), origin: "config", configHash: s.hash, position: position ?? next++ } });
+                report.created++;
+                return;
+            }
+            const data = {};
+            if (existing.origin !== "config") {
+                // A section kept from an earlier config is back in the config: adopt it, keeping the admin version.
+                Object.assign(data, { origin: "config", edited: true, conflict: true });
+                report.conflicts++;
+            }
+            else {
+                const d = syncDecision(existing, s.hash);
+                if (d === "apply") {
+                    Object.assign(data, configSectionFields(s), { configHash: s.hash });
+                    report.updated++;
+                }
+                else if (d === "conflict") {
+                    data.conflict = true;
+                    report.conflicts++;
+                }
+                else if (d === "resolve")
+                    data.conflict = false;
+            }
+            if (position !== undefined && existing.position !== position)
+                data.position = position;
+            if (Object.keys(data).length)
+                ops.push({ op: "updateSection", id: existing.id, data });
+        });
+    });
+    return { ops, report };
+}
+/** Arbitrary constant: one sync at a time across every API process sharing the database. */
+const SITE_SYNC_LOCK = 4_242_017_311;
+/** `nav` is a nullable JSON column: SQL NULL (automatic menu) can't be written through Prisma without the generated `Prisma.DbNull`. */
+async function writeNav(db, id, nav) {
+    if (nav === null)
+        await db.$executeRawUnsafe(`UPDATE "site_pages" SET "nav" = NULL WHERE "id" = $1::uuid`, id);
+}
+async function runOps(db, ops) {
+    for (const o of ops) {
+        if (o.op === "createPage")
+            await db.sitePage.create({ data: { ...o.data, sections: { create: o.sections } } });
+        else if (o.op === "updatePage") {
+            const { nav, ...data } = o.data;
+            await db.sitePage.update({ where: { id: o.id }, data: { ...data, ...(nav !== undefined && nav !== null ? { nav } : {}) } });
+            await writeNav(db, o.id, nav === undefined ? undefined : nav);
+        }
+        else if (o.op === "deletePage")
+            await db.sitePage.delete({ where: { id: o.id } });
+        else if (o.op === "createSection")
+            await db.siteSection.create({ data: o.data });
+        else if (o.op === "updateSection")
+            await db.siteSection.update({ where: { id: o.id }, data: o.data });
+        else
+            await db.siteSection.delete({ where: { id: o.id } });
+    }
+}
+/**
+ * Seed the website from forge.config.ts (idempotent): new pages and sections are inserted, untouched ones follow
+ * the config, admin edits are kept (and flagged when the config changed too). Runs at API start and in `forge db seed`,
+ * under a transaction-level advisory lock so several API processes starting together don't race. Never throws:
+ * returns null when there is no site or the tables are missing (with a "run forge db migrate" warning).
+ */
+export async function syncSite(app, prisma, options = {}) {
+    if (!app.site)
+        return null;
+    if (!prisma?.sitePage) {
+        warnMissing();
+        return null;
+    }
+    try {
+        const report = await prisma.$transaction(async (tx) => {
+            await tx.$executeRawUnsafe(`SELECT pg_advisory_xact_lock(${SITE_SYNC_LOCK})`);
+            const rows = await tx.sitePage.findMany({
+                select: { id: true, key: true, path: true, origin: true, configHash: true, edited: true, conflict: true, orderEdited: true, position: true, publishedAt: true, sections: { select: { id: true, key: true, origin: true, configHash: true, edited: true, conflict: true, removed: true, position: true } } },
+            });
+            const plan = planSiteSync(app.site, rows);
+            await runOps(tx, plan.ops);
+            return plan.report;
+        }, { timeout: 60_000, maxWait: 30_000 });
+        if (options.log !== false && (report.created || report.updated || report.conflicts || report.removed)) {
+            logger.log(`Website synced from forge.config.ts: ${report.created} created, ${report.updated} updated, ${report.removed} removed, ${report.conflicts} conflict(s)${report.conflicts ? " — review them in the admin (Content)" : ""}`);
+        }
+        return report;
+    }
+    catch (e) {
+        if (siteTablesMissing(e))
+            warnMissing();
+        else
+            logger.error(`Website sync failed: ${e.message}`);
+        return null;
+    }
+}
+/** Bot traps: the hidden "website" field is filled, or the form was sent less than 2 s after it was shown. */
+export function looksLikeSpam(body, now = Date.now()) {
+    if (typeof body.website === "string" && body.website.trim() !== "")
+        return true;
+    // Only a recent timestamp counts: a client clock running ahead (negative elapsed time) is not held against people.
+    if (typeof body.startedAt === "number" && Number.isFinite(body.startedAt)) {
+        const elapsed = now - body.startedAt;
+        if (elapsed >= 0 && elapsed < 2000)
+            return true;
+    }
+    return false;
+}
+const text = (v) => (typeof v === "string" ? v.trim() : v);
+export function validateContact(body) {
+    const b = isObject(body) ? body : {};
+    const issues = [];
+    const str = (key, min, max, required) => {
+        const v = text(b[key]);
+        if (v === undefined || v === null || v === "") {
+            if (required)
+                issues.push({ path: key, message: "Required" });
+            return undefined;
+        }
+        if (typeof v !== "string")
+            issues.push({ path: key, message: "Expected text" });
+        else if (v.length < min)
+            issues.push({ path: key, message: `Must be at least ${min} characters` });
+        else if (v.length > max)
+            issues.push({ path: key, message: `Must be at most ${max} characters` });
+        else
+            return v;
+        return undefined;
+    };
+    const name = str("name", 1, 100, true);
+    const email = str("email", 3, 200, true);
+    if (email !== undefined && !EMAIL.test(email))
+        issues.push({ path: "email", message: "Must be an email address" });
+    const company = str("company", 1, 100, false);
+    const message = str("message", 10, 5000, true);
+    const page = str("page", 1, 200, false);
+    return { issues, value: { name: name ?? "", email: (email ?? "").toLowerCase(), message: message ?? "", ...(company ? { company } : {}), ...(page ? { page } : {}) } };
+}
+export function validateNewsletter(body) {
+    const b = isObject(body) ? body : {};
+    const issues = [];
+    const email = text(b.email);
+    if (email === undefined || email === null || email === "")
+        issues.push({ path: "email", message: "Required" });
+    else if (typeof email !== "string" || email.length > 200 || !EMAIL.test(email))
+        issues.push({ path: "email", message: "Must be an email address" });
+    const source = text(b.source);
+    if (source !== undefined && source !== null && source !== "" && (typeof source !== "string" || source.length > 100))
+        issues.push({ path: "source", message: "Must be at most 100 characters" });
+    return { issues, value: { email: typeof email === "string" ? email.toLowerCase() : "", ...(typeof source === "string" && source ? { source } : {}) } };
+}
+/** In-memory sliding-window limits per IP (per API process — enough to stop a form from being flooded). */
+const hits = new Map();
+const WINDOW = 10 * 60_000;
+function rateLimited(key, max, now = Date.now()) {
+    const recent = (hits.get(key) ?? []).filter((t) => now - t < WINDOW);
+    if (recent.length >= max) {
+        hits.set(key, recent);
+        return true;
+    }
+    recent.push(now);
+    hits.set(key, recent);
+    if (hits.size > 10_000)
+        for (const [k, v] of hits)
+            if (!v.some((t) => now - t < WINDOW))
+                hits.delete(k);
+    return false;
+}
+/** Forget every contact/newsletter rate limit (tests). */
+export function resetSiteRateLimits() {
+    hits.clear();
+}
+const tooMany = () => new HttpException({ statusCode: 429, error: "Too Many Requests", message: "Too many messages from your network — try again in a few minutes" }, HttpStatus.TOO_MANY_REQUESTS);
+// ─── Posts ───────────────────────────────────────────────────────────────────────────────────
+/** "Hello, World!" → "hello-world" (accents dropped, at most 100 characters). */
+export function slugify(input) {
+    return (input
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 100)
+        .replace(/-+$/, "") || "post");
+}
+function seoInput(v, at, issues) {
+    if (v === undefined)
+        return undefined;
+    if (v === null)
+        return {};
+    if (!isObject(v)) {
+        issues.push({ path: at, message: "Must be { title?, description?, image? }" });
+        return undefined;
+    }
+    const out = {};
+    for (const k of Object.keys(v))
+        if (!["title", "description", "image"].includes(k))
+            issues.push({ path: `${at}.${k}`, message: "Unknown key (seo has title, description, image)" });
+    const t = text(v.title);
+    if (t !== undefined && t !== null && t !== "")
+        typeof t === "string" && t.length <= 120 ? (out.title = t) : issues.push({ path: `${at}.title`, message: "Must be at most 120 characters" });
+    const d = text(v.description);
+    if (d !== undefined && d !== null && d !== "")
+        typeof d === "string" && d.length <= 300 ? (out.description = d) : issues.push({ path: `${at}.description`, message: "Must be at most 300 characters" });
+    if (v.image !== undefined && v.image !== null && v.image !== "")
+        validImage(v.image) ? (out.image = v.image) : issues.push({ path: `${at}.image`, message: 'Must be an image URL (https://…) or a path such as "/og.png"' });
+    return out;
+}
+const SAMPLE_POSTS = {
+    post: [
+        { title: "Welcome to our new website", excerpt: "What we are building, and why.", tags: ["news"] },
+        { title: "Five tips to get organized", excerpt: "Small habits that keep a team's work on track.", tags: ["tips"] },
+        { title: "What's new this month", excerpt: "The latest improvements, big and small.", tags: ["product"] },
+    ],
+    guide: [
+        { title: "Getting started in ten minutes", excerpt: "From your first sign-in to a working setup.", tags: ["basics"] },
+        { title: "Inviting your team", excerpt: "Roles, permissions and the first invitations.", tags: ["teams"] },
+    ],
+    webinar: [
+        { title: "Live demo: a tour of the product", excerpt: "A recorded walkthrough with questions from the audience.", tags: ["demo"] },
+        { title: "Best practices from our customers", excerpt: "How teams like yours get the most out of it.", tags: ["customers"] },
+    ],
+    "case-study": [
+        { title: "How Northwind saved ten hours a week", excerpt: "From spreadsheets to one shared source of truth.", tags: ["operations"] },
+        { title: "Contoso's rollout to 200 people", excerpt: "A step-by-step migration without downtime.", tags: ["enterprise"] },
+    ],
+};
+/** A few published posts per post kind with a public listing, when there are no posts yet (`forge db seed`). */
+export async function seedSitePosts(app, prisma, userId) {
+    if (!app.site || !prisma?.sitePost)
+        return 0;
+    const kinds = Object.keys(app.site.blog);
+    if (!kinds.length || (await prisma.sitePost.count()) > 0)
+        return 0;
+    const author = userId ? await prisma.user.findUnique({ where: { id: userId }, select: { name: true } }) : null;
+    let n = 0;
+    for (const kind of kinds) {
+        for (const [i, p] of SAMPLE_POSTS[kind].entries()) {
+            await prisma.sitePost.create({
+                data: {
+                    kind,
+                    slug: slugify(p.title),
+                    title: p.title,
+                    excerpt: p.excerpt,
+                    body: `${p.excerpt}\n\n## Why it matters\n\nThis is a sample ${kind === "case-study" ? "case study" : kind} written by \`forge db seed\`. Edit or delete it in the admin (**Content → Posts**).\n\n- Clear and short\n- Written in markdown\n- Published on the website at once`,
+                    tags: p.tags,
+                    status: "published",
+                    publishedAt: new Date(Date.now() - (i + 1) * 3 * 86_400_000),
+                    authorId: userId,
+                    authorName: author?.name ?? `The ${app.name} team`,
+                },
+            });
+            n++;
+        }
+    }
+    return n;
+}
+// ─── Live data of sections ───────────────────────────────────────────────────────────────────
+const NUMBER = new Intl.NumberFormat("en-US", { maximumFractionDigits: 2 });
+/** A section filter ({ status: "open", "price.gte": 10, tags: ["a", "b"] }) as list-query parameters. */
+function filterQuery(filter) {
+    const out = {};
+    if (!isObject(filter))
+        return out;
+    for (const [k, v] of Object.entries(filter))
+        out[k] = Array.isArray(v) ? v.map(String).join(",") : String(v);
+    return out;
+}
+// ─── Service ─────────────────────────────────────────────────────────────────────────────────
+/**
+ * The public website: rendering for visitors (pages, posts, sitemap), the contact form and newsletter, and the
+ * admin API of site editors (pages, sections, posts, messages, subscribers). Visitors only ever see published
+ * content and data of public, non-tenant entities, computed with an anonymous context.
+ */
+export class SiteService {
+    service;
+    constructor(service) {
+        this.service = service;
+    }
+    get app() {
+        return this.service.app;
+    }
+    get prisma() {
+        return this.service.prisma;
+    }
+    get site() {
+        if (!this.app.site)
+            throw new NotFoundException("The website is not enabled");
+        return this.app.site;
+    }
+    /** The site models of the Prisma client (absent when it was generated before the site existed). */
+    get db() {
+        if (!this.prisma.sitePage)
+            throw new SiteTablesMissing();
+        return this.prisma;
+    }
+    /** Admin routes: a signed-in site editor, never an API key. */
+    editor(ctx) {
+        void this.site;
+        if (ctx.apiKey)
+            throw new ForbiddenException("API keys cannot manage the website");
+        if (!ctx.principal)
+            throw new UnauthorizedException("Sign in to continue");
+        if (!canEditSite(this.app, ctx))
+            throw new ForbiddenException("Only site editors can manage the website");
+    }
+    /** Turn "tables missing" into a clear 503 on admin and form routes. */
+    async guard(fn) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (siteTablesMissing(e)) {
+                warnMissing();
+                throw new ServiceUnavailableException(MIGRATE);
+            }
+            throw e;
+        }
+    }
+    checkApp() {
+        return { entities: this.app.entities, plugins: this.app.plugins, embedHosts: this.site.embedHosts };
+    }
+    templateCtx() {
+        return templateContext({ appName: this.app.name, ...(this.app.description ? { description: this.app.description } : {}), registration: this.app.auth.registration, entities: this.app.entities, plugins: this.app.plugins });
+    }
+    takenPaths() {
+        return {
+            entityPaths: this.app.entities.map((e) => e.path),
+            pluginPaths: [...new Set(this.app.plugins.flatMap((p) => [...p.reservedPaths, ...p.nav.map((n) => n.path.split("/")[0])]))],
+        };
+    }
+    configPage(key) {
+        return key ? this.site.pages.find((p) => p.key === key) : undefined;
+    }
+    // ─── Section data ─────────────────────────────────────────────────────────────
+    /** Live values of a section (stats, records, posts, plans); undefined for sections without data or on failure. */
+    async sectionData(type, variant, props) {
+        try {
+            switch (type) {
+                case "stats":
+                    return await this.stats(variant, props);
+                case "entityList":
+                case "entityGrid":
+                    return await this.records(type, variant, props);
+                case "blogList": {
+                    const kind = POST_KINDS.includes(props.kind) ? props.kind : "post";
+                    const limit = typeof props.limit === "number" ? Math.min(24, Math.max(1, props.limit)) : 6;
+                    const { data } = await this.publishedPosts({ kind, limit, page: 1, ...(typeof props.tag === "string" ? { tag: props.tag } : {}) });
+                    return { kind: "posts", posts: data };
+                }
+                case "pricing": {
+                    if (props.source !== "payments")
+                        return undefined;
+                    const plugin = this.app.plugins.find((p) => p.name === "payments");
+                    const plans = plugin?.options.plans ?? [];
+                    return { kind: "plans", plans: plans.map((p) => ({ id: String(p.id), name: String(p.name), price: p.price ?? null, description: p.description ?? null, features: Array.isArray(p.features) ? p.features.map(String) : [] })) };
+                }
+                default:
+                    return undefined;
+            }
+        }
+        catch (e) {
+            if (!siteTablesMissing(e))
+                logger.warn(`Website ${type} section data failed: ${e.message}`);
+            return undefined;
+        }
+    }
+    /** Static values as typed; live ones aggregated like dashboard metrics, as an anonymous visitor (public entities only). */
+    async stats(variant, props) {
+        const items = Array.isArray(props.items) ? props.items : [];
+        const checked = checkSiteSection(this.checkApp(), { type: "stats", variant, props }, "section");
+        const values = await Promise.all(items.map(async (item, i) => {
+            if (item.entity === undefined)
+                return typeof item.value === "string" ? item.value : null;
+            if (checked.issues.some((x) => x.path === `section.items[${i}]` || x.path.startsWith(`section.items[${i}].`)))
+                return null;
+            const entity = this.service.entityByName(String(item.entity));
+            if (!entity)
+                return null;
+            try {
+                const aggregate = item.aggregate ?? "count";
+                const where = this.publicWhere(entity, item.where);
+                const d = this.service.delegate(entity);
+                let v;
+                if (aggregate === "count")
+                    v = await d.count({ where });
+                else {
+                    const r = await d.aggregate({ where, [`_${aggregate}`]: { [item.field]: true } });
+                    v = r[`_${aggregate}`]?.[item.field];
+                    if ((v === null || v === undefined) && aggregate === "sum")
+                        v = 0;
+                }
+                if (v === null || v === undefined)
+                    return null;
+                const n = Number(typeof v === "object" ? String(v) : v);
+                return Number.isFinite(n) ? NUMBER.format(n) : null;
+            }
+            catch (e) {
+                if (!(e instanceof QueryError))
+                    logger.warn(`Website stat "${String(item.label)}" failed: ${e.message}`);
+                return null;
+            }
+        }));
+        return { kind: "stats", values };
+    }
+    /** Read scope of an anonymous visitor + the section's filter (same rules as the dashboard and the list API). */
+    publicWhere(entity, filter) {
+        const access = { ...this.service.queryAccess(entity, ANONYMOUS), anyField: true };
+        const filters = parseListQuery(entity, resolveTokens(filterQuery(filter), null), access).where;
+        return { AND: [...this.service.readWhere(entity, ANONYMOUS), ...filters] };
+    }
+    async records(type, variant, props) {
+        const checked = checkSiteSection(this.checkApp(), { type, variant, props }, "section");
+        if (checked.issues.length)
+            return undefined;
+        const entity = this.service.entityByName(String(checked.props.entity));
+        if (!entity)
+            return undefined;
+        const fields = checked.props.fields ?? defaultDataFields(entity);
+        const access = { ...this.service.queryAccess(entity, ANONYMOUS), anyField: true };
+        const rows = await this.service.delegate(entity).findMany({
+            where: this.publicWhere(entity, checked.props.filter),
+            orderBy: parseSort(entity, typeof checked.props.sort === "string" ? checked.props.sort : undefined, access),
+            take: typeof checked.props.limit === "number" ? checked.props.limit : 12,
+            include: relationInclude(entity),
+        });
+        // Only the chosen columns travel (each as the resource API returns it to an anonymous caller).
+        const keys = new Set(["id", ...fields]);
+        for (const f of entity.fields)
+            if (fields.includes(f.name))
+                keys.add(f.apiName).add(f.relation?.foreignKey ?? f.name);
+        const presented = await Promise.all(rows.map((r) => this.service.present(entity, r, ANONYMOUS)));
+        return { kind: "records", entity: entity.name, fields, rows: presented.map((r) => Object.fromEntries(Object.entries(r).filter(([k]) => keys.has(k)))) };
+    }
+    // ─── Public rendering ─────────────────────────────────────────────────────────
+    postSummary(row) {
+        const base = this.site.blog[row.kind];
+        return {
+            id: row.id,
+            kind: row.kind,
+            slug: row.slug,
+            title: row.title,
+            excerpt: row.excerpt ?? null,
+            coverImage: row.coverImage ?? null,
+            authorName: row.authorName ?? null,
+            publishedAt: iso(row.publishedAt),
+            tags: row.tags ?? [],
+            url: base ? `${base}/${row.slug}` : null,
+        };
+    }
+    postData(row) {
+        return { ...this.postSummary(row), body: row.body ?? "", seo: isObject(row.seo) ? row.seo : {} };
+    }
+    async sections(rows, preview) {
+        const visible = rows.filter((s) => !s.removed && (preview || !s.hidden)).sort((a, b) => a.position - b.position);
+        return Promise.all(visible.map(async (s) => {
+            const props = isObject(s.props) ? s.props : {};
+            const data = await this.sectionData(s.type, s.variant, props);
+            return { id: s.id, key: s.key, type: s.type, variant: s.variant, hidden: !!s.hidden, props, ...(data ? { data } : {}) };
+        }));
+    }
+    async pageData(row, preview) {
+        return {
+            id: row.id,
+            key: row.key ?? null,
+            path: row.path,
+            title: row.title,
+            template: row.template ?? null,
+            status: row.status === "draft" ? "draft" : "published",
+            seo: isObject(row.seo) ? row.seo : {},
+            sections: await this.sections(row.sections ?? [], preview),
+            updatedAt: iso(row.updatedAt),
+        };
+    }
+    chrome(pages) {
+        return buildSiteChrome(this.site, pages.map((p) => ({ key: p.key ?? null, path: p.path, title: p.title, status: p.status, nav: p.nav ?? null, redirect: p.redirect ?? null })), { appName: this.app.name, registration: this.app.auth.registration });
+    }
+    /** `?path=/pricing[&preview=1]` → the page, the post or the redirect at that path, with the header and footer. */
+    async render(query, ctx) {
+        const site = this.site;
+        const raw = typeof query.path === "string" ? query.path.trim() : "/";
+        if (!raw.startsWith("/") || raw.startsWith("//") || raw.length > 300)
+            throw new NotFoundException("Page not found");
+        const path = raw === "/" ? "/" : raw.replace(/\/+$/, "").toLowerCase() || "/";
+        const preview = (query.preview === "1" || query.preview === "true") && canEditSite(this.app, ctx);
+        const blog = { ...site.blog };
+        let pages;
+        try {
+            pages = await this.db.sitePage.findMany({ orderBy: [{ position: "asc" }, { path: "asc" }], select: { id: true, key: true, path: true, title: true, status: true, nav: true, redirect: true } });
+        }
+        catch (e) {
+            if (!siteTablesMissing(e))
+                throw e;
+            warnMissing();
+            return this.renderFromConfig(path, preview);
+        }
+        const chrome = this.chrome(pages);
+        const match = pages.find((p) => p.path === path);
+        if (match && (match.status === "published" || preview)) {
+            if (match.redirect)
+                return { kind: "redirect", redirect: match.redirect, chrome, blog };
+            const row = await this.db.sitePage.findUnique({ where: { id: match.id }, include: { sections: true } });
+            if (row)
+                return { kind: "page", page: await this.pageData(row, preview), chrome, blog };
+        }
+        for (const [kind, base] of Object.entries(site.blog)) {
+            if (!path.startsWith(`${base}/`))
+                continue;
+            const slug = path.slice(base.length + 1);
+            if (!SLUG.test(slug))
+                continue;
+            const post = await this.db.sitePost.findUnique({ where: { kind_slug: { kind, slug } } });
+            if (post && (preview || (post.status === "published" && (!post.publishedAt || post.publishedAt <= new Date()))))
+                return { kind: "post", post: this.postData(post), chrome, blog };
+        }
+        throw new NotFoundException("Page not found");
+    }
+    /** Until `forge db migrate` creates the tables, pages are rendered straight from the config. */
+    async renderFromConfig(path, preview) {
+        const site = this.site;
+        const chrome = buildSiteChrome(site, site.pages, { appName: this.app.name, registration: this.app.auth.registration });
+        const p = site.pages.find((x) => x.path === path && (x.status === "published" || preview));
+        if (!p)
+            throw new NotFoundException("Page not found");
+        if (p.redirect)
+            return { kind: "redirect", redirect: p.redirect, chrome, blog: { ...site.blog } };
+        const rows = p.sections.map((s, i) => ({ id: `config:${p.key}:${s.key}`, key: s.key, type: s.type, variant: s.variant, hidden: s.hidden, props: s.props, position: i, removed: false }));
+        const page = { id: `config:${p.key}`, key: p.key, path: p.path, title: p.title, template: p.template ?? null, status: p.status, seo: p.seo, sections: await this.sections(rows, preview), updatedAt: new Date(0).toISOString() };
+        return { kind: "page", page, chrome, blog: { ...site.blog } };
+    }
+    async publishedPosts(q) {
+        const where = { kind: q.kind, status: "published", publishedAt: { lte: new Date() }, ...(q.tag ? { tags: { has: q.tag } } : {}) };
+        const [total, rows] = await Promise.all([
+            this.db.sitePost.count({ where }),
+            this.db.sitePost.findMany({ where, orderBy: [{ publishedAt: "desc" }, { id: "asc" }], skip: (q.page - 1) * q.limit, take: q.limit, omit: { body: true } }),
+        ]);
+        return { data: rows.map((r) => this.postSummary(r)), total };
+    }
+    /** `?kind=post&limit=20&page=1&tag=x`: published posts, newest first. */
+    async posts(query) {
+        void this.site;
+        const kind = (query.kind ?? "post");
+        if (!POST_KINDS.includes(kind))
+            throw invalid([{ path: "kind", message: `Must be one of ${POST_KINDS.join(", ")}` }]);
+        const limit = Math.min(50, Math.max(1, Number(query.limit) || 20));
+        const page = Math.max(1, Math.floor(Number(query.page)) || 1);
+        const tag = typeof query.tag === "string" && query.tag.trim() ? query.tag.trim().slice(0, 40) : undefined;
+        try {
+            return await this.publishedPosts({ kind: kind, limit, page, ...(tag ? { tag } : {}) });
+        }
+        catch (e) {
+            if (!siteTablesMissing(e))
+                throw e;
+            warnMissing();
+            return { data: [], total: 0 };
+        }
+    }
+    async sitemap() {
+        const site = this.site;
+        try {
+            const pages = await this.db.sitePage.findMany({ where: { status: "published", redirect: null }, orderBy: [{ position: "asc" }, { path: "asc" }], select: { path: true, updatedAt: true } });
+            const kinds = Object.keys(site.blog);
+            const posts = kinds.length
+                ? await this.db.sitePost.findMany({ where: { kind: { in: kinds }, status: "published", publishedAt: { lte: new Date() } }, orderBy: { publishedAt: "desc" }, take: 5000, select: { kind: true, slug: true, updatedAt: true } })
+                : [];
+            return {
+                pages: pages.map((p) => ({ path: p.path, updatedAt: iso(p.updatedAt) })),
+                posts: posts.map((p) => ({ path: `${site.blog[p.kind]}/${p.slug}`, updatedAt: iso(p.updatedAt) })),
+            };
+        }
+        catch (e) {
+            if (!siteTablesMissing(e))
+                throw e;
+            warnMissing();
+            return { pages: site.pages.filter((p) => p.status === "published" && !p.redirect).map((p) => ({ path: p.path, updatedAt: new Date(0).toISOString() })), posts: [] };
+        }
+    }
+    // ─── Forms ────────────────────────────────────────────────────────────────────
+    /** Users whose global roles make them site editors (contact form notifications). */
+    async editorIds() {
+        const editors = this.site.editors.length ? this.site.editors : ["admin"];
+        const users = await this.prisma.user.findMany({ where: { OR: editors.map((r) => ({ role: { contains: r } })) }, select: { id: true, role: true, banned: true }, take: 500 });
+        return users.filter((u) => !u.banned && String(u.role ?? "").split(",").map((r) => r.trim()).some((r) => editors.includes(r))).map((u) => u.id);
+    }
+    async contact(body, meta) {
+        void this.site;
+        const b = isObject(body) ? body : {};
+        const { issues, value } = validateContact(b);
+        if (issues.length)
+            throw invalid(issues);
+        // Bots get the same answer as people, but nothing is stored.
+        if (looksLikeSpam(b))
+            return { ok: true };
+        if (rateLimited(`contact:${meta.ip ?? "unknown"}`, 5))
+            throw tooMany();
+        return this.guard(async () => {
+            const row = await this.db.contactMessage.create({ data: { ...value, ip: meta.ip ?? null, userAgent: meta.userAgent?.slice(0, 500) ?? null } });
+            const excerpt = row.message.length > 280 ? `${row.message.slice(0, 279).trimEnd()}…` : row.message;
+            await this.service.notifications
+                .notify(await this.editorIds(), {
+                title: `New message from ${row.name}`,
+                body: `${row.email}${row.company ? ` (${row.company})` : ""}: ${excerpt}`,
+                link: "/admin/content?tab=messages",
+                event: "site.contact",
+                organizationId: null,
+                // Emailed too when the app has a mail service.
+                email: true,
+            })
+                .catch((e) => logger.warn(`Contact notification failed: ${e.message}`));
+            return { ok: true };
+        });
+    }
+    async newsletter(body, meta) {
+        void this.site;
+        const b = isObject(body) ? body : {};
+        const { issues, value } = validateNewsletter(b);
+        if (issues.length)
+            throw invalid(issues);
+        if (looksLikeSpam(b))
+            return { ok: true };
+        if (rateLimited(`newsletter:${meta.ip ?? "unknown"}`, 10))
+            throw tooMany();
+        return this.guard(async () => {
+            try {
+                // Same answer whether the address was known or not.
+                await this.db.newsletterSubscriber.upsert({ where: { email: value.email }, create: { email: value.email, source: value.source ?? null, ip: meta.ip ?? null }, update: { status: "subscribed" } });
+            }
+            catch (e) {
+                if (e.code !== "P2002")
+                    throw e; // two concurrent sign-ups of the same address
+            }
+            return { ok: true };
+        });
+    }
+    // ─── Admin: pages ─────────────────────────────────────────────────────────────
+    listItem(p) {
+        const sections = p.sections ?? [];
+        return {
+            id: p.id,
+            key: p.key ?? null,
+            path: p.path,
+            title: p.title,
+            template: p.template ?? null,
+            status: p.status === "draft" ? "draft" : "published",
+            origin: p.origin === "admin" ? "admin" : "config",
+            edited: p.edited,
+            conflict: p.conflict,
+            sectionConflicts: sections.filter((s) => s.conflict).length,
+            sections: sections.filter((s) => !s.removed).length,
+            redirect: p.redirect ?? null,
+            updatedAt: iso(p.updatedAt),
+        };
+    }
+    async overview(ctx) {
+        this.editor(ctx);
+        return this.guard(async () => {
+            const [pages, messages, subscribers] = await Promise.all([
+                this.db.sitePage.findMany({ orderBy: [{ position: "asc" }, { path: "asc" }], include: { sections: { select: { conflict: true, removed: true } } } }),
+                this.db.contactMessage.count({ where: { status: "new" } }),
+                this.db.newsletterSubscriber.count({ where: { status: "subscribed" } }),
+            ]);
+            const items = pages.map((p) => this.listItem(p));
+            return {
+                pages: items,
+                conflicts: items.reduce((n, p) => n + (p.conflict ? 1 : 0) + p.sectionConflicts, 0),
+                messages: { new: messages },
+                subscribers: subscribers,
+                storage: this.app.plugins.some((p) => p.name === "storage"),
+                payments: this.app.plugins.some((p) => p.name === "payments"),
+                blogKinds: { ...this.site.blog },
+            };
+        });
+    }
+    async findPage(id) {
+        const row = UUID.test(id) ? await this.db.sitePage.findUnique({ where: { id }, include: { sections: { orderBy: { position: "asc" } } } }) : null;
+        if (!row)
+            throw new NotFoundException("Page not found");
+        return row;
+    }
+    async pathTaken(path, exceptId) {
+        return !!(await this.db.sitePage.findFirst({ where: { path, ...(exceptId ? { id: { not: exceptId } } : {}) }, select: { id: true } }));
+    }
+    async detail(row) {
+        const config = this.configPage(row.origin === "config" ? row.key : null);
+        const sections = await Promise.all(row.sections.map(async (s) => {
+            const props = isObject(s.props) ? s.props : {};
+            const ir = s.origin === "config" ? config?.sections.find((x) => x.key === s.key) : undefined;
+            const data = s.removed ? undefined : await this.sectionData(s.type, s.variant, props);
+            return {
+                id: s.id,
+                key: s.key,
+                type: s.type,
+                variant: s.variant,
+                hidden: s.hidden,
+                props,
+                ...(data ? { data } : {}),
+                origin: s.origin === "admin" ? "admin" : "config",
+                edited: s.edited,
+                conflict: s.conflict,
+                removed: s.removed,
+                position: s.position,
+                config: ir ? { variant: ir.variant, hidden: ir.hidden, props: ir.props } : null,
+            };
+        }));
+        return {
+            id: row.id,
+            key: row.key ?? null,
+            path: row.path,
+            title: row.title,
+            template: row.template ?? null,
+            status: row.status === "draft" ? "draft" : "published",
+            seo: isObject(row.seo) ? row.seo : {},
+            updatedAt: iso(row.updatedAt),
+            origin: row.origin === "admin" ? "admin" : "config",
+            edited: row.edited,
+            conflict: row.conflict,
+            nav: row.nav === false || isObject(row.nav) ? row.nav : null,
+            redirect: row.redirect ?? null,
+            config: config ? { title: config.title, path: config.path, seo: config.seo, status: config.status, nav: config.nav, redirect: config.redirect ?? null } : null,
+            sections,
+        };
+    }
+    async page(id, ctx) {
+        this.editor(ctx);
+        return this.guard(async () => this.detail(await this.findPage(id)));
+    }
+    /** Validated page fields (title, path, seo, nav, status, redirect); only the keys present in `body`. */
+    pageFields(body, issues) {
+        const out = {};
+        for (const k of Object.keys(body))
+            if (!["title", "path", "seo", "nav", "status", "redirect", "template"].includes(k))
+                issues.push({ path: k, message: `Unknown key "${k}"` });
+        if (body.title !== undefined) {
+            const t = text(body.title);
+            typeof t === "string" && t && t.length <= 120 ? (out.title = t) : issues.push({ path: "title", message: "Must be a text of 1 to 120 characters" });
+        }
+        if (body.path !== undefined) {
+            const problem = sitePathProblem(body.path, this.takenPaths());
+            problem ? issues.push({ path: "path", message: problem }) : (out.path = body.path);
+        }
+        const seo = seoInput(body.seo, "seo", issues);
+        if (seo)
+            out.seo = seo;
+        if (body.nav !== undefined) {
+            const nav = body.nav;
+            if (nav === null || nav === false)
+                out.nav = nav;
+            else if (!isObject(nav))
+                issues.push({ path: "nav", message: "Must be false, null or { group?, label?, footerOnly? }" });
+            else {
+                const n = {};
+                for (const k of Object.keys(nav))
+                    if (!["group", "label", "footerOnly"].includes(k))
+                        issues.push({ path: `nav.${k}`, message: "Unknown key (nav has group, label, footerOnly)" });
+                for (const k of ["group", "label"]) {
+                    const v = text(nav[k]);
+                    if (v === undefined || v === null || v === "")
+                        continue;
+                    typeof v === "string" && v.length <= 40 ? (n[k] = v) : issues.push({ path: `nav.${k}`, message: "Must be a short text (at most 40 characters)" });
+                }
+                if (nav.footerOnly !== undefined)
+                    typeof nav.footerOnly === "boolean" ? nav.footerOnly && (n.footerOnly = true) : issues.push({ path: "nav.footerOnly", message: "Must be true or false" });
+                out.nav = n;
+            }
+        }
+        if (body.status !== undefined)
+            body.status === "published" || body.status === "draft" ? (out.status = body.status) : issues.push({ path: "status", message: 'Must be "published" or "draft"' });
+        if (body.redirect !== undefined) {
+            if (body.redirect === null || body.redirect === "")
+                out.redirect = null;
+            else
+                validHref(body.redirect) ? (out.redirect = body.redirect) : issues.push({ path: "redirect", message: 'Must be a path such as "/sign-in" or an http(s) URL' });
+        }
+        return out;
+    }
+    /** New admin page, optionally from a template (sections with placeholder copy). Starts as a draft. */
+    async createPage(body, ctx) {
+        this.editor(ctx);
+        const b = isObject(body) ? body : {};
+        const issues = [];
+        if (b.title === undefined)
+            issues.push({ path: "title", message: "Required" });
+        if (b.path === undefined)
+            issues.push({ path: "path", message: "Required" });
+        const { template, status, ...rest } = b;
+        const fields = this.pageFields({ ...rest, ...(status !== undefined ? { status } : {}) }, issues);
+        if (template !== undefined && template !== null && (typeof template !== "string" || !PAGE_TEMPLATE_NAMES.includes(template)))
+            issues.push({ path: "template", message: `Unknown template (templates: ${PAGE_TEMPLATE_NAMES.join(", ")})` });
+        if (issues.length)
+            throw invalid(issues);
+        return this.guard(async () => {
+            if (await this.pathTaken(fields.path))
+                throw new ConflictException(`Another page already uses "${fields.path}"`);
+            const base = typeof template === "string" ? templatePage(template, this.templateCtx()) : undefined;
+            const keys = new Set();
+            const sections = (base?.sections ?? []).map((s, i) => {
+                const checked = checkSiteSection(this.checkApp(), { type: s.type, variant: s.variant, props: s.props });
+                let key = s.id ?? s.type;
+                for (let n = 2; keys.has(key); n++)
+                    key = `${s.id ?? s.type}-${n}`;
+                keys.add(key);
+                return { key, type: checked.type, variant: checked.variant, props: checked.props, origin: "admin", position: i };
+            });
+            const position = ((await this.db.sitePage.aggregate({ _max: { position: true } }))._max.position ?? -1) + 1;
+            const statusValue = fields.status ?? "draft";
+            const { nav, ...rest2 } = fields;
+            const navValue = nav !== undefined ? nav : base?.nav;
+            const row = await this.db.sitePage.create({
+                data: {
+                    ...rest2,
+                    ...(navValue !== undefined && navValue !== null ? { nav: navValue } : {}),
+                    seo: fields.seo ?? base?.seo ?? {},
+                    ...(typeof template === "string" ? { template } : {}),
+                    ...(fields.redirect === undefined && base?.redirect ? { redirect: base.redirect } : {}),
+                    status: statusValue,
+                    publishedAt: statusValue === "published" ? new Date() : null,
+                    origin: "admin",
+                    orderEdited: true,
+                    position,
+                    sections: { create: sections },
+                },
+            });
+            return this.detail(await this.findPage(row.id));
+        });
+    }
+    async updatePage(id, body, ctx) {
+        this.editor(ctx);
+        const b = isObject(body) ? body : {};
+        const issues = [];
+        if ("template" in b)
+            issues.push({ path: "template", message: "The template of a page can't be changed" });
+        const fields = this.pageFields(b, issues);
+        if (issues.length)
+            throw invalid(issues);
+        return this.guard(async () => {
+            const row = await this.findPage(id);
+            if (fields.path !== undefined && fields.path !== row.path && (await this.pathTaken(fields.path, id)))
+                throw new ConflictException(`Another page already uses "${fields.path}"`);
+            const data = { ...fields };
+            if (fields.status === "published" && !row.publishedAt)
+                data.publishedAt = new Date();
+            if (row.origin === "config") {
+                // Back to exactly the config version = no longer edited.
+                const config = this.configPage(row.key);
+                const merged = { title: row.title, path: row.path, seo: row.seo ?? {}, status: row.status, nav: row.nav ?? null, redirect: row.redirect ?? null, ...fields };
+                const own = { title: merged.title, path: merged.path, seo: merged.seo, status: merged.status, nav: merged.nav, ...(merged.redirect ? { redirect: merged.redirect } : {}) };
+                if (config && contentHash(own) === config.hash)
+                    Object.assign(data, { edited: false, conflict: false, configHash: config.hash });
+                else if (Object.keys(fields).length)
+                    data.edited = true;
+            }
+            const { nav, ...rest } = data;
+            await this.db.sitePage.update({ where: { id }, data: { ...rest, ...(nav !== undefined && nav !== null ? { nav } : {}) } });
+            await writeNav(this.db, id, nav);
+            return this.detail(await this.findPage(id));
+        });
+    }
+    async deletePage(id, ctx) {
+        this.editor(ctx);
+        return this.guard(async () => {
+            const row = await this.findPage(id);
+            if (row.origin === "config")
+                throw new ConflictException(`This page comes from forge.config.ts — remove it there (forge remove page ${row.key}) or unpublish it`);
+            await this.db.sitePage.delete({ where: { id } });
+        });
+    }
+    async revertPage(id, ctx) {
+        this.editor(ctx);
+        return this.guard(async () => {
+            const row = await this.findPage(id);
+            const config = row.origin === "config" ? this.configPage(row.key) : undefined;
+            if (!config)
+                throw new ConflictException("This page was created in the admin — there is no config version to go back to");
+            if (config.path !== row.path && (await this.pathTaken(config.path, id)))
+                throw new ConflictException(`Another page already uses "${config.path}" — change that page's path first`);
+            const { nav, ...fields } = configPageFields(config);
+            await this.db.sitePage.update({
+                where: { id },
+                data: { ...fields, ...(nav !== null ? { nav } : {}), edited: false, conflict: false, configHash: config.hash, ...(config.status === "published" && !row.publishedAt ? { publishedAt: new Date() } : {}) },
+            });
+            await writeNav(this.db, id, nav);
+            return this.detail(await this.findPage(id));
+        });
+    }
+    // ─── Admin: sections ──────────────────────────────────────────────────────────
+    checkSection(input) {
+        const checked = checkSiteSection(this.checkApp(), input, "section");
+        if (checked.issues.length)
+            throw invalid(checked.issues.map((i) => ({ path: i.path.replace(/^section\.?/, "") || "section", message: i.message })));
+        return checked;
+    }
+    async findSection(id) {
+        const row = UUID.test(id) ? await this.db.siteSection.findUnique({ where: { id }, include: { page: { select: { id: true, key: true, origin: true } } } }) : null;
+        if (!row)
+            throw new NotFoundException("Section not found");
+        return row;
+    }
+    configSection(row) {
+        if (row.origin !== "config" || row.page.origin !== "config")
+            return undefined;
+        return this.configPage(row.page.key)?.sections.find((s) => s.key === row.key);
+    }
+    /** `after`: index (among the visible order) of the section the new one follows; -1 = first; default: last. */
+    async addSection(pageId, body, ctx) {
+        this.editor(ctx);
+        const b = isObject(body) ? body : {};
+        if (b.props !== undefined && !isObject(b.props))
+            throw invalid([{ path: "props", message: "Must be an object" }]);
+        if (b.after !== undefined && (typeof b.after !== "number" || !Number.isInteger(b.after)))
+            throw invalid([{ path: "after", message: "Must be a section index" }]);
+        const defaults = typeof b.type === "string" ? sectionDefaults(b.type, this.templateCtx()) : {};
+        const checked = this.checkSection({ type: b.type, ...(b.variant !== undefined ? { variant: b.variant } : {}), props: { ...defaults, ...(b.props ?? {}) } });
+        return this.guard(async () => {
+            const page = await this.findPage(pageId);
+            const live = page.sections.filter((s) => !s.removed);
+            if (live.length >= MAX_PAGE_SECTIONS)
+                throw invalid([{ path: "sections", message: `At most ${MAX_PAGE_SECTIONS} sections per page` }]);
+            const at = b.after === undefined ? live.length : Math.min(live.length, Math.max(0, b.after + 1));
+            const key = `${checked.type}-${randomBytes(3).toString("hex")}`;
+            const order = [...live.slice(0, at).map((s) => s.id), null, ...live.slice(at).map((s) => s.id)];
+            await this.db.$transaction(async (tx) => {
+                await tx.siteSection.create({ data: { pageId, key, type: checked.type, variant: checked.variant, props: checked.props, origin: "admin", position: at } });
+                for (const [i, sid] of order.entries())
+                    if (sid)
+                        await tx.siteSection.update({ where: { id: sid }, data: { position: i } });
+                await tx.sitePage.update({ where: { id: pageId }, data: { orderEdited: true } });
+            });
+            return this.detail(await this.findPage(pageId));
+        });
+    }
+    async reorder(pageId, body, ctx) {
+        this.editor(ctx);
+        const ids = isObject(body) && Array.isArray(body.ids) ? body.ids : undefined;
+        if (!ids || ids.some((x) => typeof x !== "string"))
+            throw invalid([{ path: "ids", message: "Must be the list of section ids in the new order" }]);
+        return this.guard(async () => {
+            const page = await this.findPage(pageId);
+            const live = page.sections.filter((s) => !s.removed).map((s) => s.id);
+            if (ids.length !== live.length || new Set(ids).size !== ids.length || !ids.every((x) => live.includes(x))) {
+                throw invalid([{ path: "ids", message: "Must list every section of the page exactly once" }]);
+            }
+            await this.db.$transaction(async (tx) => {
+                for (const [i, sid] of ids.entries())
+                    await tx.siteSection.update({ where: { id: sid }, data: { position: i } });
+                await tx.sitePage.update({ where: { id: pageId }, data: { orderEdited: true } });
+            });
+            return this.detail(await this.findPage(pageId));
+        });
+    }
+    async updateSection(id, body, ctx) {
+        this.editor(ctx);
+        const b = isObject(body) ? body : {};
+        for (const k of Object.keys(b))
+            if (!["variant", "props", "hidden"].includes(k))
+                throw invalid([{ path: k, message: `Unknown key "${k}" (variant, props, hidden)` }]);
+        if (b.hidden !== undefined && typeof b.hidden !== "boolean")
+            throw invalid([{ path: "hidden", message: "Must be true or false" }]);
+        return this.guard(async () => {
+            const row = await this.findSection(id);
+            if (row.removed)
+                throw new ConflictException("This section was deleted — restore it first");
+            const checked = this.checkSection({ type: row.type, variant: b.variant ?? row.variant, props: b.props !== undefined ? b.props : row.props });
+            const hidden = b.hidden ?? row.hidden;
+            const data = { variant: checked.variant, props: checked.props, hidden };
+            if (row.origin === "config") {
+                // Back to exactly the config version = no longer edited.
+                const ir = this.configSection(row);
+                if (ir && contentHash({ variant: checked.variant, hidden, props: checked.props }) === ir.hash)
+                    Object.assign(data, { edited: false, conflict: false, configHash: ir.hash });
+                else
+                    data.edited = true;
+            }
+            await this.db.siteSection.update({ where: { id }, data });
+            return this.sectionDetail(id);
+        });
+    }
+    async sectionDetail(id) {
+        const row = await this.findSection(id);
+        const detail = await this.detail({ ...(await this.findPage(row.pageId)) });
+        return detail.sections.find((s) => s.id === id);
+    }
+    /** Config sections are only marked removed (so the next seed doesn't bring them back); admin sections are deleted. */
+    async deleteSection(id, ctx) {
+        this.editor(ctx);
+        return this.guard(async () => {
+            const row = await this.findSection(id);
+            if (row.origin === "config")
+                await this.db.siteSection.update({ where: { id }, data: { removed: true } });
+            else
+                await this.db.siteSection.delete({ where: { id } });
+        });
+    }
+    async revertSection(id, ctx) {
+        this.editor(ctx);
+        return this.guard(async () => {
+            const row = await this.findSection(id);
+            const ir = this.configSection(row);
+            if (!ir)
+                throw new ConflictException("This section was added in the admin — there is no config version to go back to");
+            await this.db.siteSection.update({ where: { id }, data: { type: ir.type, variant: ir.variant, hidden: ir.hidden, props: ir.props, edited: false, conflict: false, removed: false, configHash: ir.hash } });
+            return this.sectionDetail(id);
+        });
+    }
+    /** Live data for unsaved sections of the editor's preview; an entry is null when the section is invalid or has no data. */
+    async preview(body, ctx) {
+        this.editor(ctx);
+        const list = isObject(body) && Array.isArray(body.sections) ? body.sections : undefined;
+        if (!list)
+            throw invalid([{ path: "sections", message: "Must be a list of { type, variant, props }" }]);
+        if (list.length > MAX_PAGE_SECTIONS)
+            throw invalid([{ path: "sections", message: `At most ${MAX_PAGE_SECTIONS} sections` }]);
+        const data = await Promise.all(list.map(async (s) => {
+            if (!isObject(s))
+                return null;
+            const checked = checkSiteSection(this.checkApp(), { type: s.type, variant: s.variant, props: s.props }, "section");
+            if (checked.issues.length)
+                return null;
+            return (await this.sectionData(checked.type, checked.variant, checked.props)) ?? null;
+        }));
+        return { data };
+    }
+    // ─── Admin: posts ─────────────────────────────────────────────────────────────
+    postAdmin(row) {
+        return { ...this.postData(row), status: row.status === "published" ? "published" : "draft", authorId: row.authorId ?? null, createdAt: iso(row.createdAt), updatedAt: iso(row.updatedAt) };
+    }
+    postFields(b, issues, create) {
+        const out = {};
+        for (const k of Object.keys(b))
+            if (!["kind", "title", "slug", "excerpt", "coverImage", "body", "tags", "status", "publishedAt", "authorName", "seo"].includes(k))
+                issues.push({ path: k, message: `Unknown key "${k}"` });
+        if (b.kind !== undefined || create) {
+            const kind = b.kind ?? "post";
+            POST_KINDS.includes(kind) ? (out.kind = kind) : issues.push({ path: "kind", message: `Must be one of ${POST_KINDS.join(", ")}` });
+        }
+        if (b.title !== undefined || create) {
+            const t = text(b.title);
+            typeof t === "string" && t.length >= 1 && t.length <= 200 ? (out.title = t) : issues.push({ path: "title", message: t === undefined || t === "" ? "Required" : "Must be a text of 1 to 200 characters" });
+        }
+        if (b.slug !== undefined && b.slug !== null && b.slug !== "")
+            typeof b.slug === "string" && b.slug.length <= 100 && SLUG.test(b.slug) ? (out.slug = b.slug) : issues.push({ path: "slug", message: 'Must be lowercase words separated by dashes, such as "my-first-post" (at most 100 characters)' });
+        const optional = (key, max) => {
+            if (b[key] === undefined)
+                return;
+            const v = text(b[key]);
+            if (v === null || v === "")
+                out[key] = null;
+            else
+                typeof v === "string" && v.length <= max ? (out[key] = v) : issues.push({ path: key, message: `Must be at most ${max} characters` });
+        };
+        optional("excerpt", 500);
+        optional("authorName", 100);
+        if (b.body !== undefined)
+            typeof b.body === "string" && b.body.length <= 100_000 ? (out.body = b.body) : issues.push({ path: "body", message: "Must be markdown text of at most 100000 characters" });
+        if (b.coverImage !== undefined) {
+            if (b.coverImage === null || b.coverImage === "")
+                out.coverImage = null;
+            else if (!validImage(b.coverImage))
+                issues.push({ path: "coverImage", message: 'Must be an image URL (https://…) or a path such as "/cover.png"' });
+            else if (isUploadedImage(b.coverImage) && !this.app.plugins.some((p) => p.name === "storage"))
+                issues.push({ path: "coverImage", message: "Uploaded images need the storage plugin (forge add storage)" });
+            else
+                out.coverImage = b.coverImage;
+        }
+        if (b.tags !== undefined) {
+            const tags = Array.isArray(b.tags) ? b.tags.map(text) : null;
+            if (!tags || tags.length > 10 || tags.some((t) => typeof t !== "string" || !t || t.length > 40))
+                issues.push({ path: "tags", message: "At most 10 tags of at most 40 characters" });
+            else
+                out.tags = [...new Set(tags)];
+        }
+        if (b.status !== undefined)
+            b.status === "draft" || b.status === "published" ? (out.status = b.status) : issues.push({ path: "status", message: 'Must be "draft" or "published"' });
+        if (b.publishedAt !== undefined) {
+            if (b.publishedAt === null || b.publishedAt === "")
+                out.publishedAt = null;
+            else {
+                const d = typeof b.publishedAt === "string" ? new Date(b.publishedAt) : null;
+                d && !Number.isNaN(d.getTime()) ? (out.publishedAt = d) : issues.push({ path: "publishedAt", message: "Must be a date" });
+            }
+        }
+        const seo = seoInput(b.seo, "seo", issues);
+        if (seo)
+            out.seo = seo;
+        return out;
+    }
+    async findPost(id) {
+        const row = UUID.test(id) ? await this.db.sitePost.findUnique({ where: { id } }) : null;
+        if (!row)
+            throw new NotFoundException("Post not found");
+        return row;
+    }
+    async listPosts(query, ctx) {
+        this.editor(ctx);
+        const where = [];
+        if (typeof query.kind === "string" && query.kind)
+            where.push({ kind: query.kind });
+        if (query.status === "draft" || query.status === "published")
+            where.push({ status: query.status });
+        const search = typeof query.search === "string" ? query.search.trim().slice(0, 100) : "";
+        if (search)
+            where.push({ OR: [{ title: { contains: search, mode: "insensitive" } }, { slug: { contains: search.toLowerCase() } }] });
+        const pageSize = Math.min(100, Math.max(1, Number(query.pageSize) || 20));
+        const page = Math.max(1, Math.floor(Number(query.page)) || 1);
+        return this.guard(async () => {
+            const [total, rows] = await Promise.all([
+                this.db.sitePost.count({ where: { AND: where } }),
+                this.db.sitePost.findMany({ where: { AND: where }, orderBy: [{ updatedAt: "desc" }, { id: "asc" }], skip: (page - 1) * pageSize, take: pageSize }),
+            ]);
+            return { data: rows.map((r) => this.postAdmin(r)), total };
+        });
+    }
+    async getPost(id, ctx) {
+        this.editor(ctx);
+        return this.guard(async () => this.postAdmin(await this.findPost(id)));
+    }
+    async createPost(body, ctx) {
+        this.editor(ctx);
+        const issues = [];
+        const data = this.postFields(isObject(body) ? body : {}, issues, true);
+        if (issues.length)
+            throw invalid(issues);
+        return this.guard(async () => {
+            if (data.slug) {
+                if (await this.db.sitePost.findUnique({ where: { kind_slug: { kind: data.kind, slug: data.slug } } }))
+                    throw new ConflictException(`Another ${data.kind} already uses the slug "${data.slug}"`);
+            }
+            else {
+                // Unique per kind: "my-post", "my-post-2"…
+                const base = slugify(data.title);
+                const taken = new Set((await this.db.sitePost.findMany({ where: { kind: data.kind, slug: { startsWith: base } }, select: { slug: true } })).map((r) => r.slug));
+                let slug = base;
+                for (let n = 2; taken.has(slug); n++)
+                    slug = `${base.slice(0, 95)}-${n}`;
+                data.slug = slug;
+            }
+            if (data.status === "published" && !data.publishedAt)
+                data.publishedAt = new Date();
+            const row = await this.db.sitePost.create({ data: { ...data, authorId: ctx.principal.id, authorName: data.authorName ?? ctx.user?.name ?? null } });
+            return this.postAdmin(row);
+        });
+    }
+    async updatePost(id, body, ctx) {
+        this.editor(ctx);
+        const issues = [];
+        const data = this.postFields(isObject(body) ? body : {}, issues, false);
+        if (issues.length)
+            throw invalid(issues);
+        return this.guard(async () => {
+            const row = await this.findPost(id);
+            const kind = data.kind ?? row.kind;
+            const slug = data.slug ?? row.slug;
+            if ((kind !== row.kind || slug !== row.slug) && (await this.db.sitePost.findFirst({ where: { kind, slug, id: { not: id } } })))
+                throw new ConflictException(`Another ${kind} already uses the slug "${slug}"`);
+            // Publishing without a date publishes now.
+            const publishedAt = "publishedAt" in data ? data.publishedAt : row.publishedAt;
+            if ((data.status ?? row.status) === "published" && !publishedAt)
+                data.publishedAt = new Date();
+            return this.postAdmin(await this.db.sitePost.update({ where: { id }, data }));
+        });
+    }
+    async deletePost(id, ctx) {
+        this.editor(ctx);
+        return this.guard(async () => {
+            await this.findPost(id);
+            await this.db.sitePost.delete({ where: { id } });
+        });
+    }
+    // ─── Admin: messages and subscribers ─────────────────────────────────────────
+    message(r) {
+        return { id: r.id, name: r.name, email: r.email, company: r.company ?? null, message: r.message, page: r.page ?? null, status: r.status, createdAt: iso(r.createdAt) };
+    }
+    async messages(query, ctx) {
+        this.editor(ctx);
+        const where = ["new", "read", "archived"].includes(query.status) ? { status: query.status } : {};
+        const page = Math.max(1, Math.floor(Number(query.page)) || 1);
+        const pageSize = Math.min(100, Math.max(1, Number(query.pageSize) || 20));
+        return this.guard(async () => {
+            const [total, rows] = await Promise.all([this.db.contactMessage.count({ where }), this.db.contactMessage.findMany({ where, orderBy: [{ createdAt: "desc" }, { id: "asc" }], skip: (page - 1) * pageSize, take: pageSize })]);
+            return { data: rows.map((r) => this.message(r)), total: total };
+        });
+    }
+    async updateMessage(id, body, ctx) {
+        this.editor(ctx);
+        const status = isObject(body) ? body.status : undefined;
+        if (!["new", "read", "archived"].includes(status))
+            throw invalid([{ path: "status", message: 'Must be "new", "read" or "archived"' }]);
+        return this.guard(async () => {
+            const row = UUID.test(id) ? await this.db.contactMessage.findUnique({ where: { id } }) : null;
+            if (!row)
+                throw new NotFoundException("Message not found");
+            return this.message(await this.db.contactMessage.update({ where: { id }, data: { status } }));
+        });
+    }
+    async deleteMessage(id, ctx) {
+        this.editor(ctx);
+        return this.guard(async () => {
+            const { count } = UUID.test(id) ? await this.db.contactMessage.deleteMany({ where: { id } }) : { count: 0 };
+            if (!count)
+                throw new NotFoundException("Message not found");
+        });
+    }
+    subscriber(r) {
+        return { id: r.id, email: r.email, status: r.status, source: r.source ?? null, createdAt: iso(r.createdAt), updatedAt: iso(r.updatedAt) };
+    }
+    async subscribers(query, ctx) {
+        this.editor(ctx);
+        const page = Math.max(1, Math.floor(Number(query.page)) || 1);
+        const pageSize = Math.min(100, Math.max(1, Number(query.pageSize) || 20));
+        const where = query.status === "subscribed" || query.status === "unsubscribed" ? { status: query.status } : {};
+        return this.guard(async () => {
+            const [total, rows] = await Promise.all([this.db.newsletterSubscriber.count({ where }), this.db.newsletterSubscriber.findMany({ where, orderBy: [{ createdAt: "desc" }, { id: "asc" }], skip: (page - 1) * pageSize, take: pageSize })]);
+            return { data: rows.map((r) => this.subscriber(r)), total: total };
+        });
+    }
+    /** Subscribed addresses as CSV (cells that a spreadsheet would run as formulas are neutralized). */
+    async exportSubscribers(ctx) {
+        this.editor(ctx);
+        return this.guard(async () => {
+            const rows = await this.db.newsletterSubscriber.findMany({ where: { status: "subscribed" }, orderBy: { createdAt: "asc" }, take: 100_000 });
+            const cell = (v) => {
+                let s = v === null || v === undefined ? "" : String(v);
+                if (/^[=+\-@\t\r]/.test(s))
+                    s = `'${s}`;
+                return /[",\n\r]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+            };
+            return ["email,status,source,subscribed_at", ...rows.map((r) => [r.email, r.status, r.source, iso(r.createdAt)].map(cell).join(","))].join("\n") + "\n";
+        });
+    }
+    async deleteSubscriber(id, ctx) {
+        this.editor(ctx);
+        return this.guard(async () => {
+            const { count } = UUID.test(id) ? await this.db.newsletterSubscriber.deleteMany({ where: { id } }) : { count: 0 };
+            if (!count)
+                throw new NotFoundException("Subscriber not found");
+        });
+    }
+}
+//# sourceMappingURL=site.js.map