dineway 0.1.8 → 0.1.11

package/dist/comments-Gy3zLBaP.mjs

@@ -0,0 +1,186 @@
+import { t as CommentRepository } from "./comment-DFO-gWDH.mjs";
+
+//#region src/api/handlers/comments.ts
+async function handleCommentList(db, collection, contentId, options = {}) {
+	try {
+		const repo = new CommentRepository(db);
+		const total = await repo.countByContent(collection, contentId, "approved");
+		let publicItems;
+		let nextCursor;
+		if (options.threaded) {
+			const result = await repo.findByContent(collection, contentId, {
+				status: "approved",
+				limit: 500
+			});
+			publicItems = CommentRepository.assembleThreads(result.items).map((c) => CommentRepository.toPublicComment(c));
+		} else {
+			const result = await repo.findByContent(collection, contentId, {
+				status: "approved",
+				limit: options.limit,
+				cursor: options.cursor
+			});
+			publicItems = result.items.map((c) => CommentRepository.toPublicComment(c));
+			nextCursor = result.nextCursor;
+		}
+		return {
+			success: true,
+			data: {
+				items: publicItems,
+				nextCursor,
+				total
+			}
+		};
+	} catch (error) {
+		console.error("Comment list error:", error);
+		return {
+			success: false,
+			error: {
+				code: "COMMENT_LIST_ERROR",
+				message: "Failed to list comments"
+			}
+		};
+	}
+}
+async function handleCommentInbox(db, options = {}) {
+	try {
+		const repo = new CommentRepository(db);
+		const status = options.status ?? "pending";
+		const result = await repo.findByStatus(status, {
+			collection: options.collection,
+			search: options.search,
+			limit: options.limit,
+			cursor: options.cursor
+		});
+		return {
+			success: true,
+			data: {
+				items: result.items,
+				nextCursor: result.nextCursor
+			}
+		};
+	} catch (error) {
+		console.error("Comment inbox error:", error);
+		return {
+			success: false,
+			error: {
+				code: "COMMENT_INBOX_ERROR",
+				message: "Failed to list comments"
+			}
+		};
+	}
+}
+async function handleCommentCounts(db) {
+	try {
+		return {
+			success: true,
+			data: await new CommentRepository(db).countByStatus()
+		};
+	} catch (error) {
+		console.error("Comment counts error:", error);
+		return {
+			success: false,
+			error: {
+				code: "COMMENT_COUNTS_ERROR",
+				message: "Failed to get comment counts"
+			}
+		};
+	}
+}
+async function handleCommentGet(db, id) {
+	try {
+		const comment = await new CommentRepository(db).findById(id);
+		if (!comment) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Comment not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: comment
+		};
+	} catch (error) {
+		console.error("Comment get error:", error);
+		return {
+			success: false,
+			error: {
+				code: "COMMENT_GET_ERROR",
+				message: "Failed to get comment"
+			}
+		};
+	}
+}
+async function handleCommentDelete(db, id) {
+	try {
+		if (!await new CommentRepository(db).delete(id)) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Comment not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { deleted: true }
+		};
+	} catch (error) {
+		console.error("Comment delete error:", error);
+		return {
+			success: false,
+			error: {
+				code: "COMMENT_DELETE_ERROR",
+				message: "Failed to delete comment"
+			}
+		};
+	}
+}
+async function handleCommentBulk(db, ids, action) {
+	try {
+		const repo = new CommentRepository(db);
+		let affected;
+		if (action === "delete") affected = await repo.bulkDelete(ids);
+		else affected = await repo.bulkUpdateStatus(ids, {
+			approve: "approved",
+			spam: "spam",
+			trash: "trash"
+		}[action]);
+		return {
+			success: true,
+			data: { affected }
+		};
+	} catch (error) {
+		console.error("Comment bulk error:", error);
+		return {
+			success: false,
+			error: {
+				code: "COMMENT_BULK_ERROR",
+				message: "Failed to perform bulk operation"
+			}
+		};
+	}
+}
+/**
+* Check if an IP has exceeded the comment rate limit.
+* Uses ip_hash in the comments table — no separate counter storage.
+*/
+async function checkRateLimit(db, ipHash, maxPerWindow = 5, windowMinutes = 10) {
+	const cutoff = (/* @__PURE__ */ new Date(Date.now() - windowMinutes * 60 * 1e3)).toISOString();
+	const result = await db.selectFrom("_dineway_comments").select((eb) => eb.fn.count("id").as("count")).where("ip_hash", "=", ipHash).where("created_at", ">", cutoff).executeTakeFirst();
+	return Number(result?.count ?? 0) >= maxPerWindow;
+}
+/**
+* Hash an IP address for storage (never store cleartext IPs).
+*
+* Uses full SHA-256 with a site-specific salt to prevent rainbow-table
+* recovery of IPs. The caller must pass a secret resolved through
+* `resolveSecretsCached(db).ipSalt`.
+*/
+async function hashIp(ip, salt) {
+	const data = `ip:${salt}:${ip}`;
+	const buf = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(data));
+	return Array.from(new Uint8Array(buf), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+//#endregion
+export { handleCommentGet as a, hashIp as c, handleCommentDelete as i, handleCommentBulk as n, handleCommentInbox as o, handleCommentCounts as r, handleCommentList as s, checkRateLimit as t };

package/dist/components-DND2rd3D.mjs

@@ -0,0 +1,107 @@
+//#region src/widgets/components.ts
+/**
+* Core widget components registry
+* These are built-in widgets that ship with Dineway
+*/
+const coreWidgetComponents = [
+	{
+		id: "core:recent-posts",
+		label: "Recent Posts",
+		description: "Display a list of recent posts",
+		props: {
+			count: {
+				type: "number",
+				label: "Number of posts",
+				default: 5
+			},
+			showThumbnails: {
+				type: "boolean",
+				label: "Show thumbnails",
+				default: false
+			},
+			showDate: {
+				type: "boolean",
+				label: "Show date",
+				default: true
+			}
+		}
+	},
+	{
+		id: "core:categories",
+		label: "Categories",
+		description: "Display category list",
+		props: {
+			showCount: {
+				type: "boolean",
+				label: "Show post count",
+				default: true
+			},
+			hierarchical: {
+				type: "boolean",
+				label: "Show hierarchy",
+				default: true
+			}
+		}
+	},
+	{
+		id: "core:tags",
+		label: "Tags",
+		description: "Display tag cloud",
+		props: {
+			showCount: {
+				type: "boolean",
+				label: "Show count",
+				default: false
+			},
+			limit: {
+				type: "number",
+				label: "Maximum tags",
+				default: 20
+			}
+		}
+	},
+	{
+		id: "core:search",
+		label: "Search",
+		description: "Search form",
+		props: { placeholder: {
+			type: "string",
+			label: "Placeholder text",
+			default: "Search..."
+		} }
+	},
+	{
+		id: "core:archives",
+		label: "Archives",
+		description: "Monthly/yearly archives",
+		props: {
+			type: {
+				type: "select",
+				label: "Group by",
+				default: "monthly",
+				options: [{
+					value: "monthly",
+					label: "Monthly"
+				}, {
+					value: "yearly",
+					label: "Yearly"
+				}]
+			},
+			limit: {
+				type: "number",
+				label: "Limit",
+				default: 12
+			}
+		}
+	}
+];
+/**
+* Get all widget component definitions (core + plugin-registered)
+* For now, only returns core components. Plugin widgets will be added later.
+*/
+function getWidgetComponents() {
+	return [...coreWidgetComponents];
+}
+
+//#endregion
+export { getWidgetComponents as t };

package/dist/{content-DWi4d0rT.mjs → content-CyLkb-qH.mjs}

@@ -1,38 +1,10 @@
 import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
 import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
-import { n as decodeCursor, r as encodeCursor, t as DinewayValidationError } from "./types-BawVha09.mjs";
+import { n as slugify } from "./slugify-PDTDtMXp.mjs";
+import { n as decodeCursor, r as encodeCursor, t as DinewayValidationError } from "./types-Bs6lTBBW.mjs";
 import { sql } from "kysely";
 import { monotonicFactory, ulid } from "ulidx";
 
-//#region src/utils/slugify.ts
-const DIACRITICS_PATTERN = /[\u0300-\u036f]/g;
-const WHITESPACE_UNDERSCORE_PATTERN = /[\s_]+/g;
-const NON_ALPHANUMERIC_HYPHEN_PATTERN = /[^a-z0-9-]/g;
-const MULTIPLE_HYPHENS_PATTERN = /-+/g;
-const LEADING_TRAILING_HYPHEN_PATTERN = /^-|-$/g;
-const TRAILING_HYPHEN_PATTERN = /-$/;
-/**
-* Decode a URI-encoded slug route parameter before database lookup.
-*/
-function decodeSlug(raw) {
-	if (!raw) return void 0;
-	try {
-		return decodeURIComponent(raw);
-	} catch {
-		return raw;
-	}
-}
-/**
-* Convert a string to a URL-friendly slug.
-*
-* Handles unicode by normalizing to NFD and stripping diacritics,
-* so "café" becomes "cafe", "naïve" becomes "naive", etc.
-*/
-function slugify(text, maxLength = 80) {
-	return text.toLowerCase().normalize("NFD").replace(DIACRITICS_PATTERN, "").replace(WHITESPACE_UNDERSCORE_PATTERN, "-").replace(NON_ALPHANUMERIC_HYPHEN_PATTERN, "").replace(MULTIPLE_HYPHENS_PATTERN, "-").replace(LEADING_TRAILING_HYPHEN_PATTERN, "").slice(0, maxLength).replace(TRAILING_HYPHEN_PATTERN, "");
-}
-
-//#endregion
 //#region src/database/repositories/revision.ts
 const monotonic = monotonicFactory();
 /**
@@ -674,8 +646,11 @@ var ContentRepository = class {
 	* Syncs the draft revision's data into the content table columns so the
 	* content table always reflects the published version.
 	* If no draft revision exists, creates one from current data and publishes it.
+	*
+	* `publishedAt` overrides the publication timestamp. If omitted, an existing
+	* `published_at` is preserved and first publish falls back to the current time.
 	*/
-	async publish(type, id) {
+	async publish(type, id, publishedAt) {
 		const tableName = getTableName(type);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const existing = await this.findById(type, id);
@@ -696,17 +671,28 @@ var ContentRepository = class {
 					WHERE id = ${id}
 				`.execute(this.db);
 		}
-		await sql`
-			UPDATE ${sql.ref(tableName)}
-			SET live_revision_id = ${revisionToPublish},
-				draft_revision_id = NULL,
-				status = 'published',
-				scheduled_at = NULL,
-				published_at = COALESCE(published_at, ${now}),
-				updated_at = ${now}
-			WHERE id = ${id}
-			AND deleted_at IS NULL
-		`.execute(this.db);
+		if (publishedAt !== void 0) await sql`
+				UPDATE ${sql.ref(tableName)}
+				SET live_revision_id = ${revisionToPublish},
+					draft_revision_id = NULL,
+					status = 'published',
+					scheduled_at = NULL,
+					published_at = ${publishedAt},
+					updated_at = ${now}
+				WHERE id = ${id}
+				AND deleted_at IS NULL
+			`.execute(this.db);
+		else await sql`
+				UPDATE ${sql.ref(tableName)}
+				SET live_revision_id = ${revisionToPublish},
+					draft_revision_id = NULL,
+					status = 'published',
+					scheduled_at = NULL,
+					published_at = COALESCE(published_at, ${now}),
+					updated_at = ${now}
+				WHERE id = ${id}
+				AND deleted_at IS NULL
+			`.execute(this.db);
 		const updated = await this.findById(type, id);
 		if (!updated) throw new Error("Content not found");
 		return updated;
@@ -864,7 +850,10 @@ var ContentRepository = class {
 			scheduledAt: "scheduled_at",
 			deletedAt: "deleted_at",
 			title: "title",
-			slug: "slug"
+			name: "name",
+			slug: "slug",
+			status: "status",
+			locale: "locale"
 		}[field];
 		if (!mapped) throw new DinewayValidationError(`Invalid order field: ${field}`);
 		return mapped;
@@ -872,4 +861,4 @@ var ContentRepository = class {
 };
 
 //#endregion
-export { slugify as a, decodeSlug as i, content_exports as n, RevisionRepository as r, ContentRepository as t };
+export { content_exports as n, RevisionRepository as r, ContentRepository as t };

package/dist/context-bE5Kyvcj.mjs

@@ -0,0 +1,184 @@
+import { a as ContextRepository, i as parseSiteBriefingScope, n as SiteBriefingError } from "./briefing-BrXCuMEE.mjs";
+import { b as toPublicContextEntry, x as toPublicContextEntryPage, y as toPublicContextDiff } from "./site-context-Bpu_Paur.mjs";
+
+//#region src/api/handlers/context.ts
+async function handleContextEntryList(db, input = {}) {
+	try {
+		const scopes = resolveScopes(input.scope, input.includeInherited);
+		const repository = new ContextRepository(db);
+		const query = {
+			scopes,
+			contextTypes: input.contextTypes,
+			tags: input.tags,
+			createdByActorType: input.createdByActorType,
+			createdByActorId: input.createdByActorId,
+			currentOnly: input.currentOnly,
+			limit: input.limit,
+			cursor: input.cursor
+		};
+		return {
+			success: true,
+			data: toPublicContextEntryPage(input.q?.trim() ? await repository.search({
+				...query,
+				query: input.q.trim()
+			}) : await repository.list(query))
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_LIST_ERROR", "Failed to list context entries");
+	}
+}
+async function handleContextEntryGet(db, id) {
+	try {
+		const entry = await new ContextRepository(db).findById(id);
+		if (!entry) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Context entry not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { item: toPublicContextEntry(entry) }
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_GET_ERROR", "Failed to get context entry");
+	}
+}
+async function handleContextEntryCreate(db, input, actor) {
+	try {
+		parseSiteBriefingScope(input.scope);
+		return {
+			success: true,
+			data: { item: toPublicContextEntry(await new ContextRepository(db).create({
+				...input,
+				createdByActorType: actor.actorType,
+				createdByActorId: actor.actorId,
+				createdAuthMetadata: actor.authMetadata
+			})) }
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_CREATE_ERROR", "Failed to create context entry");
+	}
+}
+async function handleContextEntrySupersede(db, id, input, actor) {
+	try {
+		if (input.scope) parseSiteBriefingScope(input.scope);
+		const entry = await new ContextRepository(db).supersede(id, {
+			...input,
+			createdByActorType: actor.actorType,
+			createdByActorId: actor.actorId,
+			createdAuthMetadata: actor.authMetadata
+		});
+		if (!entry) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Context entry not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { item: toPublicContextEntry(entry) }
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_SUPERSEDE_ERROR", "Failed to supersede context entry");
+	}
+}
+async function handleContextEntryReview(db, id, input, actor) {
+	try {
+		const entry = await new ContextRepository(db).review(id, {
+			reviewedByActorType: actor.actorType,
+			reviewedByActorId: actor.actorId,
+			reviewNote: input.reviewNote,
+			validUntil: input.validUntil
+		});
+		if (!entry) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Context entry not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { item: toPublicContextEntry(entry) }
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_REVIEW_ERROR", "Failed to review context entry");
+	}
+}
+async function handleContextEntryStale(db, input = {}) {
+	try {
+		return {
+			success: true,
+			data: toPublicContextEntryPage(await new ContextRepository(db).listStale({
+				scopes: resolveScopes(input.scope, input.includeInherited),
+				contextTypes: input.contextTypes,
+				tags: input.tags,
+				now: input.now,
+				limit: input.limit,
+				cursor: input.cursor
+			}))
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_STALE_ERROR", "Failed to list stale context entries");
+	}
+}
+async function handleContextEntryDiff(db, input) {
+	try {
+		return {
+			success: true,
+			data: toPublicContextDiff(await new ContextRepository(db).diff({
+				scopes: resolveScopes(input.scope, input.includeInherited),
+				since: input.since,
+				now: input.now
+			}))
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_DIFF_ERROR", "Failed to diff context entries");
+	}
+}
+async function handleContextEntryHistory(db, id) {
+	try {
+		const repository = new ContextRepository(db);
+		if (!await repository.findById(id)) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Context entry not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { items: (await repository.findSupersedeHistory(id)).map(toPublicContextEntry) }
+		};
+	} catch (error) {
+		return contextError(error, "CONTEXT_HISTORY_ERROR", "Failed to load context history");
+	}
+}
+function resolveScopes(scope, includeInherited) {
+	if (!scope) return void 0;
+	const parsed = parseSiteBriefingScope(scope);
+	return includeInherited ? parsed.ancestors : [parsed.scope];
+}
+function contextError(error, code, fallback) {
+	if (error instanceof SiteBriefingError) return {
+		success: false,
+		error: {
+			code: "VALIDATION_ERROR",
+			message: error.message
+		}
+	};
+	console.error(`[${code}]`, error);
+	return {
+		success: false,
+		error: {
+			code,
+			message: fallback
+		}
+	};
+}
+
+//#endregion
+export { handleContextEntryList as a, handleContextEntrySupersede as c, handleContextEntryHistory as i, handleContextEntryDiff as n, handleContextEntryReview as o, handleContextEntryGet as r, handleContextEntryStale as s, handleContextEntryCreate as t };