dineway 0.1.9 → 0.1.12

package/dist/seo-contributions-B1fWCnqY.mjs

@@ -0,0 +1,429 @@
+//#region src/page/context.ts
+function isAstroInput(input) {
+	return "Astro" in input;
+}
+/**
+* Build a PublicPageContext from template input.
+*/
+function createPublicPageContext(input) {
+	let url;
+	let path;
+	let locale;
+	if (isAstroInput(input)) {
+		url = input.Astro.url.href;
+		path = input.Astro.url.pathname;
+		locale = input.Astro.currentLocale ?? null;
+	} else {
+		const parsed = typeof input.url === "string" ? new URL(input.url) : input.url;
+		url = parsed.href;
+		path = parsed.pathname;
+		locale = input.locale ?? null;
+	}
+	return {
+		url,
+		path,
+		locale,
+		kind: input.kind,
+		pageType: input.pageType ?? (input.kind === "content" ? "article" : "website"),
+		title: input.title ?? null,
+		pageTitle: input.pageTitle ?? null,
+		description: input.description ?? null,
+		canonical: input.canonical ?? null,
+		image: input.image ?? null,
+		content: input.content ? {
+			collection: input.content.collection,
+			id: input.content.id,
+			slug: input.content.slug ?? null
+		} : void 0,
+		seo: input.seo,
+		articleMeta: input.articleMeta,
+		siteName: input.siteName,
+		breadcrumbs: input.breadcrumbs,
+		siteUrl: input.siteUrl
+	};
+}
+
+//#endregion
+//#region src/page/metadata.ts
+/** Schemes safe for use in link href attributes */
+const SAFE_HREF_RE = /^(https?|at):\/\//i;
+const HTML_ESCAPE_MAP = {
+	"&": "&",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+const HTML_ESCAPE_RE = /[&<>"']/g;
+/** Escape a string for safe use in an HTML attribute value */
+function escapeHtmlAttr(value) {
+	return value.replace(HTML_ESCAPE_RE, (ch) => HTML_ESCAPE_MAP[ch] ?? ch);
+}
+/** Validate that a URL uses a safe scheme (http, https, at) */
+function isSafeHref(url) {
+	return SAFE_HREF_RE.test(url);
+}
+const JSONLD_LT_RE = /</g;
+const JSONLD_GT_RE = />/g;
+const JSONLD_U2028_RE = /\u2028/g;
+const JSONLD_U2029_RE = /\u2029/g;
+/**
+* Safely serialize a value for embedding in a <script type="application/ld+json"> tag.
+*
+* Plain JSON.stringify is not sufficient because:
+* - "<\/script>" in a nested string breaks out of the script tag
+* - "<!--" can open an HTML comment
+* - U+2028/U+2029 are line terminators in some JS engines
+*/
+function safeJsonLdSerialize(value) {
+	return JSON.stringify(value).replace(JSONLD_LT_RE, "\\u003c").replace(JSONLD_GT_RE, "\\u003e").replace(JSONLD_U2028_RE, "\\u2028").replace(JSONLD_U2029_RE, "\\u2029");
+}
+/**
+* Resolve a flat list of contributions into deduplicated metadata.
+* First contribution wins for any given dedupe key.
+*/
+function resolvePageMetadata(contributions) {
+	const result = {
+		meta: [],
+		properties: [],
+		links: [],
+		jsonld: []
+	};
+	const seenMeta = /* @__PURE__ */ new Set();
+	const seenProperties = /* @__PURE__ */ new Set();
+	const seenLinks = /* @__PURE__ */ new Set();
+	const seenJsonLd = /* @__PURE__ */ new Set();
+	for (const c of contributions) switch (c.kind) {
+		case "meta": {
+			const dedupeKey = c.key ?? c.name;
+			if (seenMeta.has(dedupeKey)) continue;
+			seenMeta.add(dedupeKey);
+			result.meta.push({
+				name: c.name,
+				content: c.content
+			});
+			break;
+		}
+		case "property": {
+			const dedupeKey = c.key ?? c.property;
+			if (seenProperties.has(dedupeKey)) continue;
+			seenProperties.add(dedupeKey);
+			result.properties.push({
+				property: c.property,
+				content: c.content
+			});
+			break;
+		}
+		case "link":
+			if (!isSafeHref(c.href)) {
+				if (import.meta.env?.DEV) console.warn(`[page:metadata] Rejected link contribution with unsafe href scheme: ${c.href}`);
+				continue;
+			}
+			if (c.rel === "canonical") {
+				if (seenLinks.has("canonical")) continue;
+				seenLinks.add("canonical");
+			} else {
+				const dedupeKey = c.key ?? c.hreflang ?? c.href;
+				if (seenLinks.has(dedupeKey)) continue;
+				seenLinks.add(dedupeKey);
+			}
+			result.links.push({
+				rel: c.rel,
+				href: c.href,
+				...c.hreflang && { hreflang: c.hreflang }
+			});
+			break;
+		case "jsonld":
+			if (c.id) {
+				if (seenJsonLd.has(c.id)) continue;
+				seenJsonLd.add(c.id);
+			}
+			result.jsonld.push({
+				id: c.id,
+				json: safeJsonLdSerialize(c.graph)
+			});
+			break;
+		default: break;
+	}
+	return result;
+}
+/** Render resolved metadata to an HTML string for embedding in <head> */
+function renderPageMetadata(metadata) {
+	const parts = [];
+	for (const m of metadata.meta) parts.push(`<meta name="${escapeHtmlAttr(m.name)}" content="${escapeHtmlAttr(m.content)}">`);
+	for (const p of metadata.properties) parts.push(`<meta property="${escapeHtmlAttr(p.property)}" content="${escapeHtmlAttr(p.content)}">`);
+	for (const l of metadata.links) {
+		let tag = `<link rel="${escapeHtmlAttr(l.rel)}" href="${escapeHtmlAttr(l.href)}"`;
+		if (l.hreflang) tag += ` hreflang="${escapeHtmlAttr(l.hreflang)}"`;
+		tag += ">";
+		parts.push(tag);
+	}
+	for (const j of metadata.jsonld) parts.push(`<script type="application/ld+json">${j.json}<\/script>`);
+	return parts.join("\n");
+}
+
+//#endregion
+//#region src/page/fragments.ts
+/** Escape sequences that would break out of a script tag */
+const SCRIPT_CLOSE_RE = /<\//g;
+/**
+* Filter contributions to a specific placement and deduplicate.
+* - Contributions with the same `key + placement` are deduped (first wins).
+* - External scripts with the same `src + placement` are deduped.
+*/
+function resolveFragments(contributions, placement) {
+	const filtered = contributions.filter((c) => c.placement === placement);
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const c of filtered) {
+		if (c.key) {
+			const dedupeKey = `key:${c.key}`;
+			if (seen.has(dedupeKey)) continue;
+			seen.add(dedupeKey);
+		} else if (c.kind === "external-script") {
+			const dedupeKey = `src:${c.src}`;
+			if (seen.has(dedupeKey)) continue;
+			seen.add(dedupeKey);
+		}
+		result.push(c);
+	}
+	return result;
+}
+const EVENT_HANDLER_RE = /^on/i;
+function renderAttributes(attrs) {
+	return Object.entries(attrs).filter(([k]) => !EVENT_HANDLER_RE.test(k)).map(([k, v]) => ` ${escapeHtmlAttr(k)}="${escapeHtmlAttr(v)}"`).join("");
+}
+/** Render a single fragment contribution to HTML */
+function renderFragment(c) {
+	switch (c.kind) {
+		case "external-script": {
+			let tag = `<script src="${escapeHtmlAttr(c.src)}"`;
+			if (c.async) tag += " async";
+			if (c.defer) tag += " defer";
+			if (c.attributes) tag += renderAttributes(c.attributes);
+			tag += "><\/script>";
+			return tag;
+		}
+		case "inline-script": {
+			let tag = "<script";
+			if (c.attributes) tag += renderAttributes(c.attributes);
+			tag += `>${c.code.replace(SCRIPT_CLOSE_RE, "<\\/")}<\/script>`;
+			return tag;
+		}
+		case "html": return c.html;
+	}
+}
+/** Render a list of fragment contributions to an HTML string */
+function renderFragments(contributions, placement) {
+	return resolveFragments(contributions, placement).map(renderFragment).join("\n");
+}
+
+//#endregion
+//#region src/page/jsonld.ts
+/**
+* Remove null/undefined values from a JSON-LD object recursively.
+* JSON-LD validators prefer absent keys over null values.
+*/
+function cleanJsonLd(obj) {
+	const cleaned = {};
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0 && value !== null) if (typeof value === "object" && !Array.isArray(value)) cleaned[key] = cleanJsonLd(value);
+	else cleaned[key] = value;
+	return cleaned;
+}
+/**
+* Build a BlogPosting JSON-LD graph from page context.
+* Used for article-type content pages.
+*/
+function buildBlogPostingJsonLd(page) {
+	if (page.pageType !== "article" || !page.canonical) return null;
+	const ogTitle = page.seo?.ogTitle ?? page.pageTitle ?? page.title;
+	const description = page.seo?.ogDescription || page.description;
+	const ogImage = page.seo?.ogImage || page.image;
+	const publishedTime = page.articleMeta?.publishedTime;
+	const modifiedTime = page.articleMeta?.modifiedTime;
+	const author = page.articleMeta?.author;
+	const siteName = page.siteName;
+	return cleanJsonLd({
+		"@context": "https://schema.org",
+		"@type": "BlogPosting",
+		headline: ogTitle,
+		description,
+		image: ogImage || void 0,
+		url: page.canonical,
+		datePublished: publishedTime || void 0,
+		dateModified: modifiedTime || publishedTime || void 0,
+		author: author ? {
+			"@type": "Person",
+			name: author
+		} : void 0,
+		publisher: siteName ? {
+			"@type": "Organization",
+			name: siteName
+		} : void 0,
+		mainEntityOfPage: {
+			"@type": "WebPage",
+			"@id": page.canonical
+		}
+	});
+}
+/**
+* Build a WebSite JSON-LD graph from page context.
+* Used for non-article pages (homepage, listing pages, etc.)
+*/
+function buildWebSiteJsonLd(page) {
+	const siteName = page.siteName;
+	if (!siteName) return null;
+	let siteUrl;
+	if (page.siteUrl) siteUrl = page.siteUrl;
+	else try {
+		siteUrl = new URL(page.url).origin;
+	} catch {
+		siteUrl = page.canonical || page.url;
+	}
+	return cleanJsonLd({
+		"@context": "https://schema.org",
+		"@type": "WebSite",
+		name: siteName,
+		url: siteUrl
+	});
+}
+
+//#endregion
+//#region src/page/seo-contributions.ts
+/**
+* Generate base metadata contributions from a page context's SEO data.
+* Returns an empty array if no SEO-relevant data is present.
+*/
+function generateBaseSeoContributions(page) {
+	const contributions = [];
+	const description = page.description;
+	const ogTitle = page.seo?.ogTitle ?? page.pageTitle ?? page.title;
+	const ogDescription = page.seo?.ogDescription || description;
+	const ogImage = page.seo?.ogImage || page.image;
+	const robots = page.seo?.robots;
+	const canonical = page.canonical;
+	const siteName = page.siteName;
+	if (description) contributions.push({
+		kind: "meta",
+		name: "description",
+		content: description
+	});
+	if (robots) contributions.push({
+		kind: "meta",
+		name: "robots",
+		content: robots
+	});
+	if (canonical) contributions.push({
+		kind: "link",
+		rel: "canonical",
+		href: canonical
+	});
+	contributions.push({
+		kind: "property",
+		property: "og:type",
+		content: page.pageType === "article" ? "article" : "website"
+	});
+	if (ogTitle) contributions.push({
+		kind: "property",
+		property: "og:title",
+		content: ogTitle
+	});
+	if (ogDescription) contributions.push({
+		kind: "property",
+		property: "og:description",
+		content: ogDescription
+	});
+	if (ogImage) contributions.push({
+		kind: "property",
+		property: "og:image",
+		content: ogImage
+	});
+	if (canonical) contributions.push({
+		kind: "property",
+		property: "og:url",
+		content: canonical
+	});
+	if (siteName) contributions.push({
+		kind: "property",
+		property: "og:site_name",
+		content: siteName
+	});
+	contributions.push({
+		kind: "meta",
+		name: "twitter:card",
+		content: ogImage ? "summary_large_image" : "summary"
+	});
+	if (ogTitle) contributions.push({
+		kind: "meta",
+		name: "twitter:title",
+		content: ogTitle
+	});
+	if (ogDescription) contributions.push({
+		kind: "meta",
+		name: "twitter:description",
+		content: ogDescription
+	});
+	if (ogImage) contributions.push({
+		kind: "meta",
+		name: "twitter:image",
+		content: ogImage
+	});
+	if (page.pageType === "article" && page.articleMeta) {
+		const { publishedTime, modifiedTime, author } = page.articleMeta;
+		if (publishedTime) contributions.push({
+			kind: "property",
+			property: "article:published_time",
+			content: publishedTime
+		});
+		if (modifiedTime) contributions.push({
+			kind: "property",
+			property: "article:modified_time",
+			content: modifiedTime
+		});
+		if (author) contributions.push({
+			kind: "property",
+			property: "article:author",
+			content: author
+		});
+	}
+	if (page.pageType === "article") {
+		const blogPosting = buildBlogPostingJsonLd(page);
+		if (blogPosting) contributions.push({
+			kind: "jsonld",
+			id: "primary",
+			graph: blogPosting
+		});
+	} else if (siteName) {
+		const webSite = buildWebSiteJsonLd(page);
+		if (webSite) contributions.push({
+			kind: "jsonld",
+			id: "primary",
+			graph: webSite
+		});
+	}
+	return contributions;
+}
+/**
+* Generate site-level SEO metadata contributions from SiteSettings.seo.
+*
+* These tags apply to every page, so they're sourced from global site settings
+* rather than page-specific context.
+*/
+function generateSiteSeoContributions(seoSettings) {
+	const contributions = [];
+	if (!seoSettings) return contributions;
+	if (seoSettings.googleVerification) contributions.push({
+		kind: "meta",
+		name: "google-site-verification",
+		content: seoSettings.googleVerification
+	});
+	if (seoSettings.bingVerification) contributions.push({
+		kind: "meta",
+		name: "msvalidate.01",
+		content: seoSettings.bingVerification
+	});
+	return contributions;
+}
+
+//#endregion
+export { cleanJsonLd as a, escapeHtmlAttr as c, safeJsonLdSerialize as d, createPublicPageContext as f, buildWebSiteJsonLd as i, renderPageMetadata as l, generateSiteSeoContributions as n, renderFragments as o, buildBlogPostingJsonLd as r, resolveFragments as s, generateBaseSeoContributions as t, resolvePageMetadata as u };

package/dist/service-CyOsm0R6.mjs

@@ -0,0 +1,194 @@
+import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { t as CommentRepository } from "./comment-DFO-gWDH.mjs";
+import { t as escapeHtml } from "./escape-BRVaw1Ai.mjs";
+
+//#region src/comments/notifications.ts
+const NOTIFICATION_SOURCE = "dineway-comments";
+const MAX_EXCERPT_LENGTH = 500;
+const CRLF_RE = /[\r\n]/g;
+/**
+* Build an email notification for a new comment.
+*/
+function buildCommentNotificationEmail(to, data) {
+	const title = data.contentTitle || `${data.collection} item`;
+	const subject = `New comment on "${title}"`.replace(CRLF_RE, " ");
+	const excerpt = data.commentBody.length > MAX_EXCERPT_LENGTH ? data.commentBody.slice(0, MAX_EXCERPT_LENGTH) + "..." : data.commentBody;
+	const adminUrl = `${data.adminBaseUrl}/admin/comments`;
+	return {
+		to,
+		subject,
+		text: [
+			`${data.commentAuthorName} commented on "${title}":`,
+			"",
+			excerpt,
+			"",
+			`View in admin: ${adminUrl}`
+		].join("\n"),
+		html: [
+			`<p><strong>${escapeHtml(data.commentAuthorName)}</strong> commented on &ldquo;${escapeHtml(title)}&rdquo;:</p>`,
+			`<blockquote style="border-left:3px solid #ccc;padding-left:12px;margin:12px 0;color:#555">${escapeHtml(excerpt)}</blockquote>`,
+			`<p><a href="${escapeHtml(adminUrl)}">View in admin</a></p>`
+		].join("\n")
+	};
+}
+/**
+* Send a comment notification to the content author if all conditions are met:
+* 1. Comment status is "approved"
+* 2. Content author exists and has an email
+* 3. Email provider is configured
+* 4. Commenter is not the content author (no self-notifications)
+*
+* Returns true if the email was sent, false if skipped.
+*/
+async function sendCommentNotification(params) {
+	const { email, comment, contentAuthor, adminBaseUrl } = params;
+	if (comment.status !== "approved") return false;
+	if (!contentAuthor?.email) return false;
+	if (!email.isAvailable()) return false;
+	if (comment.authorEmail.toLowerCase() === contentAuthor.email.toLowerCase()) return false;
+	const message = buildCommentNotificationEmail(contentAuthor.email, {
+		commentAuthorName: comment.authorName,
+		commentBody: comment.body,
+		contentTitle: params.contentTitle || "",
+		collection: comment.collection,
+		adminBaseUrl
+	});
+	await email.send(message, NOTIFICATION_SOURCE);
+	return true;
+}
+/**
+* Look up a content item's author from the database.
+*
+* Used by the admin moderation route where content info isn't
+* readily available (only the comment record is at hand).
+*/
+async function lookupContentAuthor(db, collection, contentId) {
+	validateIdentifier(collection, "collection");
+	const contentRow = await db.selectFrom(`ec_${collection}`).select(["slug", "author_id"]).where("id", "=", contentId).executeTakeFirst();
+	if (!contentRow) return null;
+	const typed = contentRow;
+	let author;
+	if (typed.author_id) {
+		const userRow = await db.selectFrom("users").select([
+			"id",
+			"name",
+			"email",
+			"email_verified"
+		]).where("id", "=", typed.author_id).executeTakeFirst();
+		if (userRow && userRow.email_verified) author = {
+			id: userRow.id,
+			email: userRow.email,
+			name: userRow.name
+		};
+	}
+	return {
+		slug: typed.slug,
+		author
+	};
+}
+
+//#endregion
+//#region src/comments/service.ts
+/**
+* Create a comment through the full hook pipeline.
+*
+* Returns null if the comment was rejected by a beforeCreate handler.
+*/
+async function createComment(db, input, collectionSettings, hooks, contentInfo) {
+	const repo = new CommentRepository(db);
+	const beforeCreateEvent = {
+		comment: {
+			collection: input.collection,
+			contentId: input.contentId,
+			parentId: input.parentId ?? null,
+			authorName: input.authorName,
+			authorEmail: input.authorEmail,
+			authorUserId: input.authorUserId ?? null,
+			body: input.body,
+			ipHash: input.ipHash ?? null,
+			userAgent: input.userAgent ?? null
+		},
+		metadata: {}
+	};
+	const result = await hooks.runBeforeCreate(beforeCreateEvent);
+	if (result === false) return null;
+	const event = result;
+	const priorApprovedCount = await repo.countApprovedByEmail(event.comment.authorEmail);
+	const moderateEvent = {
+		comment: event.comment,
+		metadata: event.metadata,
+		collectionSettings,
+		priorApprovedCount
+	};
+	const decision = await hooks.runModerate(moderateEvent);
+	const comment = await repo.create({
+		collection: event.comment.collection,
+		contentId: event.comment.contentId,
+		parentId: event.comment.parentId,
+		authorName: event.comment.authorName,
+		authorEmail: event.comment.authorEmail,
+		authorUserId: event.comment.authorUserId,
+		body: event.comment.body,
+		status: decision.status,
+		ipHash: event.comment.ipHash,
+		userAgent: event.comment.userAgent,
+		moderationMetadata: Object.keys(event.metadata).length > 0 ? event.metadata : null
+	});
+	if (contentInfo) {
+		const afterEvent = {
+			comment: commentToStored(comment),
+			metadata: event.metadata,
+			content: {
+				id: contentInfo.id,
+				collection: contentInfo.collection,
+				slug: contentInfo.slug,
+				title: contentInfo.title
+			},
+			contentAuthor: contentInfo.author
+		};
+		hooks.fireAfterCreate(afterEvent);
+	}
+	return {
+		comment,
+		decision
+	};
+}
+/**
+* Admin moderation — change a comment's status.
+* Fires comment:afterModerate hook.
+*/
+async function moderateComment(db, id, newStatus, moderator, hooks) {
+	const repo = new CommentRepository(db);
+	const existing = await repo.findById(id);
+	if (!existing) return null;
+	const previousStatus = existing.status;
+	const updated = await repo.updateStatus(id, newStatus);
+	if (!updated) return null;
+	const afterEvent = {
+		comment: commentToStored(updated),
+		previousStatus,
+		newStatus,
+		moderator
+	};
+	hooks.fireAfterModerate(afterEvent);
+	return updated;
+}
+function commentToStored(comment) {
+	return {
+		id: comment.id,
+		collection: comment.collection,
+		contentId: comment.contentId,
+		parentId: comment.parentId,
+		authorName: comment.authorName,
+		authorEmail: comment.authorEmail,
+		authorUserId: comment.authorUserId,
+		body: comment.body,
+		status: comment.status,
+		moderationMetadata: comment.moderationMetadata,
+		createdAt: comment.createdAt,
+		updatedAt: comment.updatedAt
+	};
+}
+
+//#endregion
+export { sendCommentNotification as i, moderateComment as n, lookupContentAuthor as r, createComment as t };