hazo_blog 0.1.0

package/dist/repository/index.js

@@ -0,0 +1,285 @@
+// hazo_blog — typed repository over hazo_connect.
+// Server-only. Uses createCrudService for writes and QueryBuilder-backed reads.
+//
+// The "live" gate (published OR scheduled-and-due) is expressed as a single
+// portable predicate: status <> 'draft' AND publish_date <= now. The service
+// guarantees published/scheduled posts always carry a publish_date, so drafts
+// (and future-scheduled posts) are naturally excluded on both SQLite and
+// PostgreSQL without engine-specific SQL.
+import { randomUUID } from "node:crypto";
+import { createCrudService } from "hazo_connect/server";
+import { safeJsonParse } from "hazo_core";
+function generateId() {
+    return randomUUID();
+}
+const POSTS = "hazo_blog_posts";
+const CATEGORIES = "hazo_blog_categories";
+const TAGS = "hazo_blog_tags";
+const POST_TAGS = "hazo_blog_post_tags";
+function nowIso() {
+    return new Date().toISOString();
+}
+function parseFaq(faqJson) {
+    const parsed = safeJsonParse(faqJson ?? "[]");
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed.filter((x) => !!x && typeof x.question === "string" && typeof x.answer === "string");
+}
+export function createBlogRepository(adapter, options = {}) {
+    const scope = options.scope ?? null;
+    const a = adapter;
+    const posts = createCrudService(a, POSTS);
+    const categories = createCrudService(a, CATEGORIES);
+    const tags = createCrudService(a, TAGS);
+    const postTags = createCrudService(a, POST_TAGS);
+    /** Apply the tenant-scope filter to a query builder when a scope is set. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function scoped(qb) {
+        return scope ? qb.where("scope_id", "eq", scope) : qb;
+    }
+    /** Apply the live-status gate to a query builder. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function live(qb) {
+        return qb.where("status", "neq", "draft").where("publish_date", "lte", nowIso());
+    }
+    async function resolveTagsFor(postIds) {
+        const map = new Map();
+        if (postIds.length === 0)
+            return map;
+        const links = await postTags.list(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (qb) => qb.whereIn("post_id", postIds));
+        const tagIds = [...new Set(links.map((l) => l.tag_id))];
+        if (tagIds.length === 0)
+            return map;
+        const allTags = await tags.list(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (qb) => qb.whereIn("id", tagIds));
+        const byId = new Map(allTags.map((t) => [t.id, t]));
+        for (const link of links) {
+            const tag = byId.get(link.tag_id);
+            if (!tag)
+                continue;
+            const arr = map.get(link.post_id) ?? [];
+            arr.push(tag);
+            map.set(link.post_id, arr);
+        }
+        return map;
+    }
+    async function hydrate(rows) {
+        if (rows.length === 0)
+            return [];
+        const catIds = [...new Set(rows.map((r) => r.category_id).filter(Boolean))];
+        const cats = catIds.length > 0
+            ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                await categories.list((qb) => qb.whereIn("id", catIds))
+            : [];
+        const catById = new Map(cats.map((c) => [c.id, c]));
+        const tagMap = await resolveTagsFor(rows.map((r) => r.id));
+        return rows.map((r) => ({
+            ...r,
+            category: r.category_id ? catById.get(r.category_id) ?? null : null,
+            tags: tagMap.get(r.id) ?? [],
+            faq: parseFaq(r.faq_json),
+        }));
+    }
+    return {
+        async listPosts(query = {}) {
+            const page = Math.max(1, query.page ?? 1);
+            const perPage = Math.max(1, query.perPage ?? 10);
+            // Optional category filter → resolve slug to id.
+            let categoryId;
+            if (query.categorySlug) {
+                const cat = await categories.findOneBy(scope
+                    ? { slug: query.categorySlug, scope_id: scope }
+                    : { slug: query.categorySlug });
+                if (!cat)
+                    return { posts: [], total: 0 };
+                categoryId = cat.id;
+            }
+            // Optional tag filter → resolve slug to the set of post ids.
+            let tagPostIds;
+            if (query.tagSlug) {
+                const tag = await tags.findOneBy(scope ? { slug: query.tagSlug, scope_id: scope } : { slug: query.tagSlug });
+                if (!tag)
+                    return { posts: [], total: 0 };
+                const links = await postTags.list(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (qb) => qb.where("tag_id", "eq", tag.id));
+                tagPostIds = links.map((l) => l.post_id);
+                if (tagPostIds.length === 0)
+                    return { posts: [], total: 0 };
+            }
+            const all = await posts.list(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (qb) => {
+                let b = scoped(qb);
+                if (!query.includeUnpublished)
+                    b = live(b);
+                if (categoryId)
+                    b = b.where("category_id", "eq", categoryId);
+                if (tagPostIds)
+                    b = b.whereIn("id", tagPostIds);
+                return b.order("publish_date", "desc");
+            });
+            const total = all.length;
+            const slice = all.slice((page - 1) * perPage, (page - 1) * perPage + perPage);
+            return { posts: await hydrate(slice), total };
+        },
+        async getPostBySlug(slug, includeUnpublished = false) {
+            const row = await posts.findOneBy(scope ? { slug, scope_id: scope } : { slug });
+            if (!row)
+                return null;
+            if (!includeUnpublished) {
+                const isLive = row.status !== "draft" &&
+                    !!row.publish_date &&
+                    new Date(row.publish_date).getTime() <= Date.now();
+                if (!isLive)
+                    return null;
+            }
+            const [hydrated] = await hydrate([row]);
+            return hydrated ?? null;
+        },
+        async getAllSlugs(includeUnpublished = false) {
+            const rows = await posts.list(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (qb) => {
+                let b = scoped(qb);
+                if (!includeUnpublished)
+                    b = live(b);
+                return b;
+            });
+            return rows.map((r) => r.slug);
+        },
+        async upsertPost(row, tagSlugs) {
+            const existing = await posts.findOneBy(scope ? { slug: row.slug, scope_id: scope } : { slug: row.slug });
+            let saved;
+            if (existing) {
+                const [updated] = await posts.updateById(existing.id, {
+                    ...row,
+                    updated_at: nowIso(),
+                });
+                saved = updated;
+            }
+            else {
+                const [inserted] = await posts.insert({
+                    id: generateId(),
+                    scope_id: scope,
+                    created_at: nowIso(),
+                    updated_at: nowIso(),
+                    ...row,
+                });
+                saved = inserted;
+            }
+            if (tagSlugs)
+                await this.setPostTags(saved.id, tagSlugs);
+            return saved;
+        },
+        async deletePost(id) {
+            // Best-effort link cleanup for engines without enforced ON DELETE CASCADE
+            // (SQLite requires PRAGMA foreign_keys=ON), then delete the post.
+            const links = await postTags.list(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (qb) => qb.where("post_id", "eq", id));
+            await Promise.all(links.map((l) => postTags.deleteById(l.id)));
+            await posts.deleteById(id);
+        },
+        async setPostTags(postId, tagSlugs) {
+            const desired = [];
+            for (const name of tagSlugs) {
+                desired.push(await this.getOrCreateTag(name));
+            }
+            const existing = await postTags.list(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (qb) => qb.where("post_id", "eq", postId));
+            const existingTagIds = new Set(existing.map((e) => e.tag_id));
+            const desiredIds = new Set(desired.map((t) => t.id));
+            // Add missing links.
+            for (const tag of desired) {
+                if (!existingTagIds.has(tag.id)) {
+                    await postTags.insert({ id: generateId(), post_id: postId, tag_id: tag.id });
+                }
+            }
+            // Remove stale links by their surrogate id.
+            for (const link of existing) {
+                if (!desiredIds.has(link.tag_id)) {
+                    await postTags.deleteById(link.id);
+                }
+            }
+        },
+        async listCategories() {
+            return categories.list(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (qb) => scoped(qb).order("name", "asc"));
+        },
+        async getOrCreateCategory(input) {
+            const slug = input.slug ?? input.name;
+            const found = await categories.findOneBy(scope ? { slug, scope_id: scope } : { slug });
+            if (found)
+                return found;
+            const [created] = await categories.insert({
+                id: generateId(),
+                scope_id: scope,
+                slug,
+                name: input.name,
+                description: "",
+                colour: "#3B82F6",
+                created_at: nowIso(),
+                updated_at: nowIso(),
+            });
+            return created;
+        },
+        async listTags() {
+            return tags.list(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (qb) => scoped(qb).order("name", "asc"));
+        },
+        async getOrCreateTag(name) {
+            const found = await tags.findOneBy(scope ? { name, scope_id: scope } : { name });
+            if (found)
+                return found;
+            const [created] = await tags.insert({
+                id: generateId(),
+                scope_id: scope,
+                slug: name,
+                name,
+                created_at: nowIso(),
+                updated_at: nowIso(),
+            });
+            return created;
+        },
+        async getRelatedPosts(post, limit = 3) {
+            const { posts: candidates } = await this.listPosts({ perPage: 50 });
+            const tagSlugs = new Set(post.tags.map((t) => t.slug));
+            const scored = candidates
+                .filter((p) => p.id !== post.id)
+                .map((p) => {
+                let score = 0;
+                if (post.category_id && p.category_id === post.category_id)
+                    score += 2;
+                for (const t of p.tags)
+                    if (tagSlugs.has(t.slug))
+                        score += 1;
+                return { p, score };
+            })
+                .sort((a, b) => b.score - a.score);
+            return scored.slice(0, limit).map((s) => s.p);
+        },
+        async searchPosts(term, limit = 20) {
+            const q = term.trim();
+            if (!q)
+                return [];
+            const needle = `%${q}%`;
+            const rows = await posts.list(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (qb) => live(scoped(qb))
+                .whereOr([
+                { field: "title", operator: "like", value: needle },
+                { field: "content", operator: "like", value: needle },
+            ])
+                .order("publish_date", "desc")
+                .limit(limit));
+            return hydrate(rows);
+        },
+    };
+}

package/dist/seo/index.d.ts

@@ -0,0 +1,44 @@
+import type { AuthorInfo, BlogPostWithRelations, ResolvedBlogConfig } from "../types/index.js";
+/** Absolute URL for a post. */
+export declare function postUrl(config: ResolvedBlogConfig, slug: string): string;
+/** Absolute URL for the blog index. */
+export declare function indexUrl(config: ResolvedBlogConfig): string;
+/** Absolute URL for a tag page. */
+export declare function tagUrl(config: ResolvedBlogConfig, tagSlug: string): string;
+/** Resolve the canonical URL for a post (per-post override wins). */
+export declare function canonicalFor(config: ResolvedBlogConfig, post: BlogPostWithRelations): string;
+/** Resolve the OG image for a post, falling back to the site default. */
+export declare function ogImageFor(config: ResolvedBlogConfig, post: BlogPostWithRelations): string;
+/** A post is indexable only when it is live (published/scheduled-due). */
+export declare function isIndexable(post: BlogPostWithRelations): boolean;
+/** Build schema.org BlogPosting JSON-LD for a post. */
+export declare function buildBlogPostingJsonLd(config: ResolvedBlogConfig, post: BlogPostWithRelations, author: AuthorInfo): Record<string, unknown>;
+/** Build schema.org FAQPage JSON-LD, or null when there are no FAQ items. */
+export declare function buildFaqJsonLd(post: BlogPostWithRelations): Record<string, unknown> | null;
+/** Build schema.org BreadcrumbList JSON-LD: Home → Blog → Post. */
+export declare function buildBreadcrumbJsonLd(config: ResolvedBlogConfig, post: BlogPostWithRelations): Record<string, unknown>;
+/** A single sitemap entry (shape matches Next.js MetadataRoute.Sitemap items). */
+export interface SitemapEntry {
+    url: string;
+    lastModified: string;
+    changeFrequency: "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+    priority: number;
+}
+/**
+ * Build sitemap entries for the blog. Host merges these into its root sitemap.
+ * Includes the index + each live post (drafts/future-scheduled excluded).
+ */
+export declare function getBlogSitemapEntries(config: ResolvedBlogConfig, posts: BlogPostWithRelations[]): SitemapEntry[];
+/** robots.txt rules the host spreads into its root robots config. */
+export interface RobotsRules {
+    allow: string[];
+    disallow: string[];
+    sitemap: string;
+}
+export declare function getBlogRobotsRules(config: ResolvedBlogConfig): RobotsRules;
+/**
+ * Build an RSS 2.0 feed XML string for the blog. Descriptions are plain-text
+ * excerpts (feeds don't execute MDX components). Only live posts are included.
+ */
+export declare function getBlogRssXml(config: ResolvedBlogConfig, posts: BlogPostWithRelations[]): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/seo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/seo/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,UAAU,EACV,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,mBAAmB,CAAC;AAS3B,+BAA+B;AAC/B,wBAAgB,OAAO,CAAC,MAAM,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAExE;AAED,uCAAuC;AACvC,wBAAgB,QAAQ,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAE3D;AAED,mCAAmC;AACnC,wBAAgB,MAAM,CAAC,MAAM,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,MAAM,EAAE,kBAAkB,EAAE,IAAI,EAAE,qBAAqB,GAAG,MAAM,CAE5F;AAED,yEAAyE;AACzE,wBAAgB,UAAU,CAAC,MAAM,EAAE,kBAAkB,EAAE,IAAI,EAAE,qBAAqB,GAAG,MAAM,CAE1F;AAED,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAIhE;AAED,uDAAuD;AACvD,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,qBAAqB,EAC3B,MAAM,EAAE,UAAU,GACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA0BzB;AAED,6EAA6E;AAC7E,wBAAgB,cAAc,CAC5B,IAAI,EAAE,qBAAqB,GAC1B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAWhC;AAED,mEAAmE;AACnE,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,qBAAqB,GAC1B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAezB;AAED,kFAAkF;AAClF,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EACX,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,OAAO,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,qBAAqB,EAAE,GAC7B,YAAY,EAAE,CAmBhB;AAED,qEAAqE;AACrE,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,WAAW,CAM1E;AAWD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,qBAAqB,EAAE,GAC7B,MAAM,CAoCR"}

package/dist/seo/index.js

@@ -0,0 +1,175 @@
+// hazo_blog — SEO emission helpers (GSC/Bing-ready).
+// Pure, server/client-neutral builders: JSON-LD, sitemap entries, robots rules,
+// RSS/Atom feeds, and canonical/OG metadata. No I/O — callers pass data in.
+import { buildExcerpt, mdxToPlainText } from "../lib/text.js";
+const DEFAULT_BASE_PATH = "/blog";
+function basePath(config) {
+    return config.basePath || DEFAULT_BASE_PATH;
+}
+/** Absolute URL for a post. */
+export function postUrl(config, slug) {
+    return `${config.baseUrl}${basePath(config)}/${slug}`;
+}
+/** Absolute URL for the blog index. */
+export function indexUrl(config) {
+    return `${config.baseUrl}${basePath(config)}`;
+}
+/** Absolute URL for a tag page. */
+export function tagUrl(config, tagSlug) {
+    return `${config.baseUrl}${basePath(config)}/tag/${tagSlug}`;
+}
+/** Resolve the canonical URL for a post (per-post override wins). */
+export function canonicalFor(config, post) {
+    return post.canonical_url || postUrl(config, post.slug);
+}
+/** Resolve the OG image for a post, falling back to the site default. */
+export function ogImageFor(config, post) {
+    return post.og_image || post.featured_image || config.defaultOgImage;
+}
+/** A post is indexable only when it is live (published/scheduled-due). */
+export function isIndexable(post) {
+    if (post.status === "draft")
+        return false;
+    if (!post.publish_date)
+        return false;
+    return new Date(post.publish_date).getTime() <= Date.now();
+}
+/** Build schema.org BlogPosting JSON-LD for a post. */
+export function buildBlogPostingJsonLd(config, post, author) {
+    const url = canonicalFor(config, post);
+    const text = mdxToPlainText(post.content);
+    return {
+        "@context": "https://schema.org",
+        "@type": "BlogPosting",
+        headline: post.meta_title || post.title,
+        description: post.meta_description || buildExcerpt(post.content),
+        image: ogImageFor(config, post),
+        datePublished: post.publish_date ?? post.created_at,
+        dateModified: post.updated_at,
+        inLanguage: "en",
+        ...(post.category ? { articleSection: post.category.name } : {}),
+        wordCount: text ? text.split(/\s+/).length : 0,
+        author: {
+            "@type": "Person",
+            name: author.name,
+            url: author.url,
+        },
+        publisher: {
+            "@type": "Organization",
+            name: config.siteName,
+            logo: { "@type": "ImageObject", url: config.logoUrl },
+        },
+        mainEntityOfPage: { "@type": "WebPage", "@id": url },
+    };
+}
+/** Build schema.org FAQPage JSON-LD, or null when there are no FAQ items. */
+export function buildFaqJsonLd(post) {
+    if (!post.faq || post.faq.length === 0)
+        return null;
+    return {
+        "@context": "https://schema.org",
+        "@type": "FAQPage",
+        mainEntity: post.faq.map((item) => ({
+            "@type": "Question",
+            name: item.question,
+            acceptedAnswer: { "@type": "Answer", text: item.answer },
+        })),
+    };
+}
+/** Build schema.org BreadcrumbList JSON-LD: Home → Blog → Post. */
+export function buildBreadcrumbJsonLd(config, post) {
+    return {
+        "@context": "https://schema.org",
+        "@type": "BreadcrumbList",
+        itemListElement: [
+            { "@type": "ListItem", position: 1, name: config.siteName, item: config.baseUrl },
+            { "@type": "ListItem", position: 2, name: "Blog", item: indexUrl(config) },
+            {
+                "@type": "ListItem",
+                position: 3,
+                name: post.title,
+                item: canonicalFor(config, post),
+            },
+        ],
+    };
+}
+/**
+ * Build sitemap entries for the blog. Host merges these into its root sitemap.
+ * Includes the index + each live post (drafts/future-scheduled excluded).
+ */
+export function getBlogSitemapEntries(config, posts) {
+    const entries = [
+        {
+            url: indexUrl(config),
+            lastModified: new Date().toISOString(),
+            changeFrequency: "weekly",
+            priority: 0.8,
+        },
+    ];
+    for (const post of posts) {
+        if (!isIndexable(post))
+            continue;
+        entries.push({
+            url: postUrl(config, post.slug),
+            lastModified: post.updated_at,
+            changeFrequency: "weekly",
+            priority: 0.7,
+        });
+    }
+    return entries;
+}
+export function getBlogRobotsRules(config) {
+    return {
+        allow: [basePath(config)],
+        disallow: [`${basePath(config)}/admin`],
+        sitemap: `${config.baseUrl}/sitemap.xml`,
+    };
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+/**
+ * Build an RSS 2.0 feed XML string for the blog. Descriptions are plain-text
+ * excerpts (feeds don't execute MDX components). Only live posts are included.
+ */
+export function getBlogRssXml(config, posts) {
+    const items = posts
+        .filter(isIndexable)
+        .map((post) => {
+        const url = canonicalFor(config, post);
+        const description = post.meta_description || buildExcerpt(post.content, 300);
+        const pubDate = new Date(post.publish_date ?? post.created_at).toUTCString();
+        return [
+            "    <item>",
+            `      <title>${escapeXml(post.title)}</title>`,
+            `      <link>${escapeXml(url)}</link>`,
+            `      <guid isPermaLink="true">${escapeXml(url)}</guid>`,
+            `      <pubDate>${pubDate}</pubDate>`,
+            post.category ? `      <category>${escapeXml(post.category.name)}</category>` : "",
+            `      <description>${escapeXml(description)}</description>`,
+            "    </item>",
+        ]
+            .filter(Boolean)
+            .join("\n");
+    })
+        .join("\n");
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<rss version="2.0">',
+        "  <channel>",
+        `    <title>${escapeXml(config.siteName)} Blog</title>`,
+        `    <link>${escapeXml(indexUrl(config))}</link>`,
+        `    <description>${escapeXml(config.siteName)} blog</description>`,
+        "    <language>en</language>",
+        items,
+        "  </channel>",
+        "</rss>",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}

package/dist/service/index.d.ts

@@ -0,0 +1,21 @@
+import type { AuthorInfo, BlogConfig, BlogPost, BlogPostWithRelations, PaginatedPosts, ResolvedBlogConfig, UpsertPostInput } from "../types/index.js";
+import { type BlogRepository, type ListQuery } from "../repository/index.js";
+/** Apply defaults to a host-supplied BlogConfig. */
+export declare function resolveConfig(config: BlogConfig): ResolvedBlogConfig;
+export interface BlogService {
+    config: ResolvedBlogConfig;
+    /** Build a repository scoped to a request (uses resolveScope when present). */
+    repository(req?: Request): Promise<BlogRepository>;
+    listPosts(query?: ListQuery, req?: Request): Promise<PaginatedPosts>;
+    getPost(slug: string, opts?: {
+        includeUnpublished?: boolean;
+    }, req?: Request): Promise<BlogPostWithRelations | null>;
+    getAllSlugs(includeUnpublished?: boolean, req?: Request): Promise<string[]>;
+    upsertBySlug(input: UpsertPostInput, req?: Request): Promise<BlogPost>;
+    deletePost(id: string, req?: Request): Promise<void>;
+    resolveAuthor(post: BlogPostWithRelations): Promise<AuthorInfo>;
+    getRelatedPosts(post: BlogPostWithRelations, limit?: number, req?: Request): Promise<BlogPostWithRelations[]>;
+    search(term: string, limit?: number, req?: Request): Promise<BlogPostWithRelations[]>;
+}
+export declare function createBlogService(rawConfig: BlogConfig): BlogService;
+//# sourceMappingURL=index.d.ts.map

package/dist/service/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/service/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,QAAQ,EACR,qBAAqB,EACrB,cAAc,EACd,kBAAkB,EAClB,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,SAAS,EACf,MAAM,wBAAwB,CAAC;AAGhC,oDAAoD;AACpD,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,kBAAkB,CAMpE;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,+EAA+E;IAC/E,UAAU,CAAC,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IACnD,SAAS,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IACrE,OAAO,CACL,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE;QAAE,kBAAkB,CAAC,EAAE,OAAO,CAAA;KAAE,EACvC,GAAG,CAAC,EAAE,OAAO,GACZ,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAAC;IACzC,WAAW,CAAC,kBAAkB,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC5E,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IACvE,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,aAAa,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAChE,eAAe,CACb,IAAI,EAAE,qBAAqB,EAC3B,KAAK,CAAC,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,OAAO,GACZ,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAAC;IACpC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAAC;CACvF;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,UAAU,GAAG,WAAW,CA6GpE"}

package/dist/service/index.js

@@ -0,0 +1,110 @@
+// hazo_blog — service layer. Resolves config defaults, builds a scoped
+// repository per request, and owns business logic (slug/reading-time/publish
+// rules, author resolution, FAQ serialization). Server-only.
+import { createBlogRepository, } from "../repository/index.js";
+import { buildExcerpt, calculateReadingTime, slugify } from "../lib/text.js";
+/** Apply defaults to a host-supplied BlogConfig. */
+export function resolveConfig(config) {
+    return {
+        ...config,
+        basePath: config.basePath?.replace(/\/$/, "") || "/blog",
+        revalidateSeconds: config.revalidateSeconds ?? 3600,
+    };
+}
+export function createBlogService(rawConfig) {
+    const config = resolveConfig(rawConfig);
+    async function repository(req) {
+        const adapter = await config.getHazoConnect();
+        const scope = req && config.resolveScope ? config.resolveScope(req) : null;
+        return createBlogRepository(adapter, { scope });
+    }
+    return {
+        config,
+        repository,
+        async listPosts(query = {}, req) {
+            const repo = await repository(req);
+            const perPage = Math.max(1, query.perPage ?? 10);
+            const page = Math.max(1, query.page ?? 1);
+            const { posts, total } = await repo.listPosts({ ...query, page, perPage });
+            return {
+                posts,
+                total,
+                page,
+                perPage,
+                totalPages: Math.max(1, Math.ceil(total / perPage)),
+            };
+        },
+        async getPost(slug, opts = {}, req) {
+            const repo = await repository(req);
+            return repo.getPostBySlug(slug, opts.includeUnpublished ?? false);
+        },
+        async getAllSlugs(includeUnpublished = false, req) {
+            const repo = await repository(req);
+            return repo.getAllSlugs(includeUnpublished);
+        },
+        async upsertBySlug(input, req) {
+            const repo = await repository(req);
+            const slug = input.slug?.trim() ? slugify(input.slug) : slugify(input.title);
+            const status = input.status ?? "draft";
+            // Resolve category from name when an id isn't supplied.
+            let categoryId = input.category_id ?? null;
+            if (!categoryId && input.category_name) {
+                const cat = await repo.getOrCreateCategory({ name: input.category_name });
+                categoryId = cat.id;
+            }
+            // Publish-date rules: published/scheduled must carry a date so the live
+            // gate works. Published with no date → now. Scheduled keeps its future
+            // date. Draft clears the date.
+            let publishDate = input.publish_date ?? null;
+            if (status === "published" && !publishDate) {
+                publishDate = new Date().toISOString();
+            }
+            else if (status === "draft") {
+                publishDate = null;
+            }
+            const faq = input.faq ?? [];
+            const row = {
+                slug,
+                title: input.title,
+                content: input.content,
+                excerpt: buildExcerpt(input.content),
+                reading_time: calculateReadingTime(input.content),
+                category_id: categoryId,
+                author_id: input.author_id ?? null,
+                meta_title: input.meta_title ?? "",
+                meta_description: input.meta_description ?? buildExcerpt(input.content),
+                canonical_url: input.canonical_url ?? null,
+                og_image: input.og_image ?? null,
+                featured_image: input.featured_image ?? null,
+                image_ref: input.image_ref ?? null,
+                faq_json: JSON.stringify(faq),
+                status,
+                publish_date: publishDate,
+            };
+            return repo.upsertPost(row, input.tags);
+        },
+        async deletePost(id, req) {
+            const repo = await repository(req);
+            await repo.deletePost(id);
+        },
+        async resolveAuthor(post) {
+            if (post.author_id && config.getAuthor) {
+                try {
+                    return await config.getAuthor(post.author_id);
+                }
+                catch {
+                    return config.author;
+                }
+            }
+            return config.author;
+        },
+        async getRelatedPosts(post, limit = 3, req) {
+            const repo = await repository(req);
+            return repo.getRelatedPosts(post, limit);
+        },
+        async search(term, limit = 20, req) {
+            const repo = await repository(req);
+            return repo.searchPosts(term, limit);
+        },
+    };
+}