dineway 0.1.9 → 0.1.12

package/dist/menus-DS3_5nWY.mjs

@@ -0,0 +1,312 @@
+import { t as withTransaction } from "./transaction-x2tJQ-A1.mjs";
+import { ulid } from "ulidx";
+
+//#region src/api/handlers/menus.ts
+/**
+* List all menus with item counts.
+*/
+async function handleMenuList(db) {
+	try {
+		const menus = await db.selectFrom("_dineway_menus").select([
+			"id",
+			"name",
+			"label",
+			"created_at",
+			"updated_at"
+		]).orderBy("name", "asc").execute();
+		return {
+			success: true,
+			data: await Promise.all(menus.map(async (menu) => {
+				const { count } = await db.selectFrom("_dineway_menu_items").select(({ fn }) => fn.countAll().as("count")).where("menu_id", "=", menu.id).executeTakeFirstOrThrow();
+				return {
+					...menu,
+					itemCount: count
+				};
+			}))
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_LIST_ERROR",
+				message: "Failed to fetch menus"
+			}
+		};
+	}
+}
+/**
+* Create a new menu.
+*/
+async function handleMenuCreate(db, input) {
+	try {
+		if (await db.selectFrom("_dineway_menus").select("id").where("name", "=", input.name).executeTakeFirst()) return {
+			success: false,
+			error: {
+				code: "CONFLICT",
+				message: `Menu with name "${input.name}" already exists`
+			}
+		};
+		const id = ulid();
+		await db.insertInto("_dineway_menus").values({
+			id,
+			name: input.name,
+			label: input.label
+		}).execute();
+		return {
+			success: true,
+			data: await db.selectFrom("_dineway_menus").selectAll().where("id", "=", id).executeTakeFirstOrThrow()
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_CREATE_ERROR",
+				message: "Failed to create menu"
+			}
+		};
+	}
+}
+/**
+* Get a single menu with all its items.
+*/
+async function handleMenuGet(db, name) {
+	try {
+		const menu = await db.selectFrom("_dineway_menus").selectAll().where("name", "=", name).executeTakeFirst();
+		if (!menu) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu not found"
+			}
+		};
+		const items = await db.selectFrom("_dineway_menu_items").selectAll().where("menu_id", "=", menu.id).orderBy("sort_order", "asc").execute();
+		return {
+			success: true,
+			data: {
+				...menu,
+				items
+			}
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_GET_ERROR",
+				message: "Failed to fetch menu"
+			}
+		};
+	}
+}
+/**
+* Update a menu's metadata.
+*/
+async function handleMenuUpdate(db, name, input) {
+	try {
+		const menu = await db.selectFrom("_dineway_menus").select("id").where("name", "=", name).executeTakeFirst();
+		if (!menu) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu not found"
+			}
+		};
+		if (input.label) await db.updateTable("_dineway_menus").set({ label: input.label }).where("id", "=", menu.id).execute();
+		return {
+			success: true,
+			data: await db.selectFrom("_dineway_menus").selectAll().where("id", "=", menu.id).executeTakeFirstOrThrow()
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_UPDATE_ERROR",
+				message: "Failed to update menu"
+			}
+		};
+	}
+}
+/**
+* Delete a menu and its items (cascade).
+*/
+async function handleMenuDelete(db, name) {
+	try {
+		const menu = await db.selectFrom("_dineway_menus").select("id").where("name", "=", name).executeTakeFirst();
+		if (!menu) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu not found"
+			}
+		};
+		await db.deleteFrom("_dineway_menus").where("id", "=", menu.id).execute();
+		return {
+			success: true,
+			data: { deleted: true }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_DELETE_ERROR",
+				message: "Failed to delete menu"
+			}
+		};
+	}
+}
+/**
+* Add an item to a menu.
+*/
+async function handleMenuItemCreate(db, menuName, input) {
+	try {
+		const menu = await db.selectFrom("_dineway_menus").select("id").where("name", "=", menuName).executeTakeFirst();
+		if (!menu) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu not found"
+			}
+		};
+		let sortOrder = input.sortOrder ?? 0;
+		if (input.sortOrder === void 0) sortOrder = ((await db.selectFrom("_dineway_menu_items").select(({ fn }) => fn.max("sort_order").as("max")).where("menu_id", "=", menu.id).where("parent_id", "is", input.parentId ?? null).executeTakeFirst())?.max ?? -1) + 1;
+		const id = ulid();
+		await db.insertInto("_dineway_menu_items").values({
+			id,
+			menu_id: menu.id,
+			parent_id: input.parentId ?? null,
+			sort_order: sortOrder,
+			type: input.type,
+			reference_collection: input.referenceCollection ?? null,
+			reference_id: input.referenceId ?? null,
+			custom_url: input.customUrl ?? null,
+			label: input.label,
+			title_attr: input.titleAttr ?? null,
+			target: input.target ?? null,
+			css_classes: input.cssClasses ?? null
+		}).execute();
+		return {
+			success: true,
+			data: await db.selectFrom("_dineway_menu_items").selectAll().where("id", "=", id).executeTakeFirstOrThrow()
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_ITEM_CREATE_ERROR",
+				message: "Failed to create menu item"
+			}
+		};
+	}
+}
+/**
+* Update a menu item.
+*/
+async function handleMenuItemUpdate(db, menuName, itemId, input) {
+	try {
+		const menu = await db.selectFrom("_dineway_menus").select("id").where("name", "=", menuName).executeTakeFirst();
+		if (!menu) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu not found"
+			}
+		};
+		if (!await db.selectFrom("_dineway_menu_items").select("id").where("id", "=", itemId).where("menu_id", "=", menu.id).executeTakeFirst()) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu item not found"
+			}
+		};
+		const updates = {};
+		if (input.label !== void 0) updates.label = input.label;
+		if (input.customUrl !== void 0) updates.custom_url = input.customUrl;
+		if (input.target !== void 0) updates.target = input.target;
+		if (input.titleAttr !== void 0) updates.title_attr = input.titleAttr;
+		if (input.cssClasses !== void 0) updates.css_classes = input.cssClasses;
+		if (input.parentId !== void 0) updates.parent_id = input.parentId;
+		if (input.sortOrder !== void 0) updates.sort_order = input.sortOrder;
+		if (Object.keys(updates).length > 0) await db.updateTable("_dineway_menu_items").set(updates).where("id", "=", itemId).execute();
+		return {
+			success: true,
+			data: await db.selectFrom("_dineway_menu_items").selectAll().where("id", "=", itemId).executeTakeFirstOrThrow()
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_ITEM_UPDATE_ERROR",
+				message: "Failed to update menu item"
+			}
+		};
+	}
+}
+/**
+* Delete a menu item.
+*/
+async function handleMenuItemDelete(db, menuName, itemId) {
+	try {
+		const menu = await db.selectFrom("_dineway_menus").select("id").where("name", "=", menuName).executeTakeFirst();
+		if (!menu) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu not found"
+			}
+		};
+		if ((await db.deleteFrom("_dineway_menu_items").where("id", "=", itemId).where("menu_id", "=", menu.id).execute())[0]?.numDeletedRows === 0n) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu item not found"
+			}
+		};
+		return {
+			success: true,
+			data: { deleted: true }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_ITEM_DELETE_ERROR",
+				message: "Failed to delete menu item"
+			}
+		};
+	}
+}
+/**
+* Batch reorder menu items.
+*/
+async function handleMenuItemReorder(db, menuName, items) {
+	try {
+		const menu = await db.selectFrom("_dineway_menus").select("id").where("name", "=", menuName).executeTakeFirst();
+		if (!menu) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Menu not found"
+			}
+		};
+		return {
+			success: true,
+			data: await withTransaction(db, async (trx) => {
+				for (const item of items) await trx.updateTable("_dineway_menu_items").set({
+					parent_id: item.parentId,
+					sort_order: item.sortOrder
+				}).where("id", "=", item.id).where("menu_id", "=", menu.id).execute();
+				return trx.selectFrom("_dineway_menu_items").selectAll().where("menu_id", "=", menu.id).orderBy("sort_order", "asc").execute();
+			})
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MENU_REORDER_ERROR",
+				message: "Failed to reorder menu items"
+			}
+		};
+	}
+}
+
+//#endregion
+export { handleMenuItemDelete as a, handleMenuList as c, handleMenuItemCreate as i, handleMenuUpdate as l, handleMenuDelete as n, handleMenuItemReorder as o, handleMenuGet as r, handleMenuItemUpdate as s, handleMenuCreate as t };

package/dist/menus-DYW_UHjv.mjs

@@ -0,0 +1,256 @@
+import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { t as CommentRepository } from "./comment-DFO-gWDH.mjs";
+import { r as getDb } from "./loader-PZnPxFLc.mjs";
+import { n as requestCached } from "./request-cache-DHMRr2Lf.mjs";
+import { n as sanitizeHref } from "./url-DNjT2abR.mjs";
+import { sql } from "kysely";
+
+//#region src/comments/query.ts
+/**
+* Get approved comments for a content item.
+*
+* @example
+* ```ts
+* import { getComments } from "dineway";
+*
+* const { items, total } = await getComments({
+*   collection: "posts",
+*   contentId: post.id,
+*   threaded: true,
+* });
+* ```
+*/
+async function getComments(options) {
+	return getCommentsWithDb(await getDb(), options);
+}
+/**
+* Get approved comments with an explicit db handle.
+*
+* @internal Use `getComments()` in templates. This variant is for routes
+* that already have a database handle.
+*/
+async function getCommentsWithDb(db, options) {
+	const repo = new CommentRepository(db);
+	const total = await repo.countByContent(options.collection, options.contentId, "approved");
+	const result = await repo.findByContent(options.collection, options.contentId, {
+		status: "approved",
+		limit: 500
+	});
+	if (options.threaded) return {
+		items: CommentRepository.assembleThreads(result.items).map((c) => CommentRepository.toPublicComment(c)),
+		total
+	};
+	return {
+		items: result.items.map((c) => CommentRepository.toPublicComment(c)),
+		total
+	};
+}
+/**
+* Get the count of approved comments for a content item.
+*
+* @example
+* ```ts
+* import { getCommentCount } from "dineway";
+*
+* const count = await getCommentCount("posts", post.id);
+* ```
+*/
+async function getCommentCount(collection, contentId) {
+	return getCommentCountWithDb(await getDb(), collection, contentId);
+}
+/**
+* Get comment count with an explicit db handle.
+*
+* @internal Use `getCommentCount()` in templates.
+*/
+async function getCommentCountWithDb(db, collection, contentId) {
+	return new CommentRepository(db).countByContent(collection, contentId, "approved");
+}
+
+//#endregion
+//#region src/menus/index.ts
+/**
+* Get menu by name with resolved URLs
+*
+* @example
+* ```ts
+* import { getMenu } from "dineway";
+*
+* const menu = await getMenu("primary");
+* if (menu) {
+*   console.log(menu.items); // Array of MenuItem with resolved URLs
+* }
+* ```
+*/
+function getMenu(name) {
+	return requestCached(`menu:${name}`, async () => {
+		return getMenuWithDb(name, await getDb());
+	});
+}
+/**
+* Get menu by name with resolved URLs (with explicit db)
+*
+* @internal Use `getMenu()` in templates. This variant is for admin routes
+* that already have a database handle.
+*/
+async function getMenuWithDb(name, db) {
+	const menuRow = await db.selectFrom("_dineway_menus").selectAll().where("name", "=", name).executeTakeFirst();
+	if (!menuRow) return null;
+	const items = await buildMenuTree(await db.selectFrom("_dineway_menu_items").selectAll().$castTo().where("menu_id", "=", menuRow.id).orderBy("sort_order", "asc").execute(), db);
+	return {
+		id: menuRow.id,
+		name: menuRow.name,
+		label: menuRow.label,
+		items
+	};
+}
+/**
+* Get all menus (without items - for admin list)
+*
+* @example
+* ```ts
+* import { getMenus } from "dineway";
+*
+* const menus = await getMenus();
+* console.log(menus); // [{ id, name, label }]
+* ```
+*/
+async function getMenus() {
+	return getMenusWithDb(await getDb());
+}
+/**
+* Get all menus (with explicit db)
+*
+* @internal Use `getMenus()` in templates. This variant is for admin routes
+* that already have a database handle.
+*/
+async function getMenusWithDb(db) {
+	return await db.selectFrom("_dineway_menus").select([
+		"id",
+		"name",
+		"label"
+	]).orderBy("name", "asc").execute();
+}
+/**
+* Build hierarchical menu tree from flat array of items
+*/
+async function buildMenuTree(items, db) {
+	const collectionSlugs = /* @__PURE__ */ new Set();
+	for (const item of items) {
+		if (item.reference_collection) collectionSlugs.add(item.reference_collection);
+		if (item.type === "page" || item.type === "post") collectionSlugs.add(item.reference_collection || `${item.type}s`);
+	}
+	const urlPatterns = /* @__PURE__ */ new Map();
+	if (collectionSlugs.size > 0) {
+		const rows = await db.selectFrom("_dineway_collections").select(["slug", "url_pattern"]).where("slug", "in", [...collectionSlugs]).execute();
+		for (const row of rows) urlPatterns.set(row.slug, row.url_pattern);
+	}
+	const validItems = (await Promise.all(items.map((item) => resolveMenuItem(item, db, urlPatterns)))).filter((item) => item !== null);
+	const itemMap = /* @__PURE__ */ new Map();
+	const rootItems = [];
+	for (const item of validItems) itemMap.set(item.id, {
+		...item,
+		children: []
+	});
+	for (const item of items) {
+		const menuItem = itemMap.get(item.id);
+		if (!menuItem) continue;
+		if (item.parent_id) {
+			const parent = itemMap.get(item.parent_id);
+			if (parent) parent.children.push(menuItem);
+			else rootItems.push(menuItem);
+		} else rootItems.push(menuItem);
+	}
+	return rootItems;
+}
+/**
+* Resolve a single menu item's URL
+*
+* Returns null if the referenced content no longer exists (item should be skipped)
+*/
+async function resolveMenuItem(item, db, urlPatterns) {
+	let url;
+	try {
+		switch (item.type) {
+			case "custom":
+				url = item.custom_url || "#";
+				break;
+			case "page":
+			case "post":
+				url = await resolveContentUrl(item.reference_collection || `${item.type}s`, item.reference_id, db, urlPatterns);
+				if (url === null) return null;
+				break;
+			case "taxonomy":
+				url = await resolveTaxonomyUrl(item.reference_id, db);
+				if (url === null) return null;
+				break;
+			case "collection":
+				url = `/${item.reference_collection}/`;
+				break;
+			default: if (item.reference_collection && item.reference_id) {
+				url = await resolveContentUrl(item.reference_collection, item.reference_id, db, urlPatterns);
+				if (url === null) return null;
+			} else url = "#";
+		}
+	} catch (error) {
+		console.error(`Failed to resolve menu item ${item.id}:`, error);
+		return null;
+	}
+	return {
+		id: item.id,
+		label: item.label,
+		url: sanitizeHref(url),
+		target: item.target || void 0,
+		titleAttr: item.title_attr || void 0,
+		cssClasses: item.css_classes || void 0,
+		children: []
+	};
+}
+const SLUG_PLACEHOLDER = /\{slug\}/g;
+const ID_PLACEHOLDER = /\{id\}/g;
+/**
+* Interpolate a URL pattern with entry data
+*
+* Replaces `{slug}` and `{id}` placeholders.
+*/
+function interpolateUrlPattern(pattern, slug, id) {
+	return pattern.replace(SLUG_PLACEHOLDER, slug).replace(ID_PLACEHOLDER, id);
+}
+/**
+* Resolve URL for a content entry (page/post)
+*
+* Uses the collection's url_pattern if set, otherwise falls back to /{collection}/{slug}.
+* Returns null if content not found (item should be skipped).
+*/
+async function resolveContentUrl(collection, entryId, db, urlPatterns) {
+	if (!entryId) return null;
+	try {
+		validateIdentifier(collection, "menu item collection");
+		const row = (await sql`
+			SELECT slug FROM ${sql.ref(`ec_${collection}`)} WHERE id = ${entryId} LIMIT 1
+		`.execute(db)).rows[0];
+		if (row) {
+			const pattern = urlPatterns.get(collection);
+			if (pattern) return interpolateUrlPattern(pattern, row.slug, entryId);
+			return `/${collection}/${row.slug}`;
+		}
+		return null;
+	} catch (error) {
+		console.error(`Failed to resolve content URL for ${collection}/${entryId}:`, error);
+		return null;
+	}
+}
+/**
+* Resolve URL for a taxonomy term
+*
+* Returns null if taxonomy not found (item should be skipped)
+*/
+async function resolveTaxonomyUrl(taxonomyId, db) {
+	if (!taxonomyId) return null;
+	const taxonomy = await db.selectFrom("taxonomies").select(["name", "slug"]).where("id", "=", taxonomyId).executeTakeFirst();
+	if (!taxonomy) return null;
+	return `/${taxonomy.name}/${taxonomy.slug}`;
+}
+
+//#endregion
+export { getComments as i, getMenus as n, getCommentCount as r, getMenu as t };

package/dist/normalize-C49G_o1k.mjs

@@ -0,0 +1,126 @@
+//#region src/media/normalize.ts
+const INTERNAL_MEDIA_PREFIX = "/_dineway/api/media/file/";
+const URL_PATTERN = /^https?:\/\//;
+/**
+* Normalize a media field value into a consistent MediaValue shape.
+*
+* - `null`/`undefined` → `null`
+* - Bare URL string → `{ provider: "external", id: "", src: url }`
+* - Bare internal media URL → resolved via local provider's `get()`
+* - Object with `provider` + `id` → enriched with missing fields from provider
+*/
+async function normalizeMediaValue(value, getProvider) {
+	if (value == null) return null;
+	if (typeof value === "string") return normalizeStringUrl(value, getProvider);
+	if (!isRecord(value)) return null;
+	if (!("id" in value) && !("src" in value)) return null;
+	const provider = (typeof value.provider === "string" ? value.provider : void 0) || "local";
+	const id = typeof value.id === "string" ? value.id : "";
+	if (provider === "external") return recordToMediaValue(value);
+	const result = {
+		...recordToMediaValue(value),
+		provider
+	};
+	if (provider === "local") delete result.src;
+	const needsDimensions = result.width == null || result.height == null;
+	const needsStorageKey = provider === "local" && !result.meta?.storageKey;
+	const needsFileInfo = !result.mimeType || !result.filename;
+	if (!(needsDimensions || needsStorageKey || needsFileInfo) || !id) return result;
+	const mediaProvider = getProvider(provider);
+	if (!mediaProvider?.get) return result;
+	let providerItem;
+	try {
+		providerItem = await mediaProvider.get(id);
+	} catch {
+		return result;
+	}
+	if (!providerItem) return result;
+	return mergeProviderData(result, providerItem);
+}
+function normalizeStringUrl(url, getProvider) {
+	if (url.startsWith(INTERNAL_MEDIA_PREFIX)) return resolveInternalUrl(url, getProvider);
+	if (URL_PATTERN.test(url)) return Promise.resolve({
+		provider: "external",
+		id: "",
+		src: url
+	});
+	return Promise.resolve({
+		provider: "external",
+		id: "",
+		src: url
+	});
+}
+async function resolveInternalUrl(url, getProvider) {
+	const storageKey = url.slice(25);
+	const localProvider = getProvider("local");
+	if (!localProvider?.get) return {
+		provider: "external",
+		id: "",
+		src: url
+	};
+	let item;
+	try {
+		item = await localProvider.get(storageKey);
+	} catch {
+		return {
+			provider: "external",
+			id: "",
+			src: url
+		};
+	}
+	if (!item) return {
+		provider: "external",
+		id: "",
+		src: url
+	};
+	return {
+		provider: "local",
+		id: item.id,
+		filename: item.filename,
+		mimeType: item.mimeType,
+		width: item.width,
+		height: item.height,
+		alt: item.alt,
+		meta: item.meta
+	};
+}
+/**
+* Merge provider data into an existing MediaValue, preserving caller-supplied fields.
+* Caller `alt` takes priority over provider `alt` (per-usage, not per-image).
+*/
+function mergeProviderData(existing, item) {
+	const result = { ...existing };
+	if (result.width == null && item.width != null) result.width = item.width;
+	if (result.height == null && item.height != null) result.height = item.height;
+	if (!result.filename && item.filename) result.filename = item.filename;
+	if (!result.mimeType && item.mimeType) result.mimeType = item.mimeType;
+	if (!result.alt && item.alt) result.alt = item.alt;
+	if (item.meta) result.meta = {
+		...item.meta,
+		...result.meta
+	};
+	return result;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Extract known MediaValue fields from a runtime-checked record.
+* Avoids unsafe `as MediaValue` cast by reading each property explicitly.
+*/
+function recordToMediaValue(obj) {
+	const result = { id: typeof obj.id === "string" ? obj.id : "" };
+	if (typeof obj.provider === "string") result.provider = obj.provider;
+	if (typeof obj.src === "string") result.src = obj.src;
+	if (typeof obj.previewUrl === "string") result.previewUrl = obj.previewUrl;
+	if (typeof obj.filename === "string") result.filename = obj.filename;
+	if (typeof obj.mimeType === "string") result.mimeType = obj.mimeType;
+	if (typeof obj.width === "number") result.width = obj.width;
+	if (typeof obj.height === "number") result.height = obj.height;
+	if (typeof obj.alt === "string") result.alt = obj.alt;
+	if (isRecord(obj.meta)) result.meta = obj.meta;
+	return result;
+}
+
+//#endregion
+export { normalizeMediaValue as t };