dineway 0.1.14 → 0.1.16

package/dist/menus-DS3_5nWY.mjs

@@ -1,312 +0,0 @@
-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/taxonomies-D2aZGuns.mjs

@@ -1,270 +0,0 @@
-import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-D_jVet6z.mjs";
-import { r as getDb } from "./loader-PZnPxFLc.mjs";
-import { n as requestCached, r as setRequestCacheEntry, t as peekRequestCache } from "./request-cache-DHMRr2Lf.mjs";
-import { t as isMissingTableError } from "./db-errors-DyZkswzF.mjs";
-
-//#region src/taxonomies/index.ts
-/**
-* Runtime API for taxonomies
-*
-* Provides functions to query taxonomy definitions and terms.
-*/
-var taxonomies_exports = /* @__PURE__ */ __exportAll({
-	getAllTermsForEntries: () => getAllTermsForEntries,
-	getEntriesByTerm: () => getEntriesByTerm,
-	getEntryTerms: () => getEntryTerms,
-	getTaxonomyDef: () => getTaxonomyDef,
-	getTaxonomyDefs: () => getTaxonomyDefs,
-	getTaxonomyTerms: () => getTaxonomyTerms,
-	getTerm: () => getTerm,
-	getTermsForEntries: () => getTermsForEntries,
-	invalidateTermCache: () => invalidateTermCache
-});
-function invalidateTermCache() {}
-/**
-* Get all taxonomy definitions
-*/
-async function getTaxonomyDefs() {
-	return requestCached("taxonomy-defs:all", async () => {
-		return (await (await getDb()).selectFrom("_dineway_taxonomy_defs").selectAll().execute()).map((row) => ({
-			id: row.id,
-			name: row.name,
-			label: row.label,
-			labelSingular: row.label_singular ?? void 0,
-			hierarchical: row.hierarchical === 1,
-			collections: row.collections ? JSON.parse(row.collections) : []
-		}));
-	});
-}
-/**
-* Get a single taxonomy definition by name
-*/
-async function getTaxonomyDef(name) {
-	const allDefs = peekRequestCache("taxonomy-defs:all");
-	if (allDefs) return (await allDefs).find((def) => def.name === name) ?? null;
-	return requestCached(`taxonomy-def:${name}`, async () => {
-		const row = await (await getDb()).selectFrom("_dineway_taxonomy_defs").selectAll().where("name", "=", name).executeTakeFirst();
-		if (!row) return null;
-		return {
-			id: row.id,
-			name: row.name,
-			label: row.label,
-			labelSingular: row.label_singular ?? void 0,
-			hierarchical: row.hierarchical === 1,
-			collections: row.collections ? JSON.parse(row.collections) : []
-		};
-	});
-}
-/**
-* Get all terms for a taxonomy (as tree for hierarchical, flat for tags)
-*/
-async function getTaxonomyTerms(taxonomyName) {
-	return requestCached(`taxonomy-terms:${taxonomyName}`, async () => {
-		const db = await getDb();
-		const def = await getTaxonomyDef(taxonomyName);
-		if (!def) return [];
-		const rows = await db.selectFrom("taxonomies").selectAll().where("name", "=", taxonomyName).orderBy("label", "asc").execute();
-		const countsResult = await db.selectFrom("content_taxonomies").select(["taxonomy_id"]).select((eb) => eb.fn.count("entry_id").as("count")).groupBy("taxonomy_id").execute();
-		const counts = /* @__PURE__ */ new Map();
-		for (const row of countsResult) counts.set(row.taxonomy_id, row.count);
-		const flatTerms = rows.map((row) => ({
-			id: row.id,
-			name: row.name,
-			slug: row.slug,
-			label: row.label,
-			parent_id: row.parent_id,
-			data: row.data
-		}));
-		if (def.hierarchical) return buildTree(flatTerms, counts);
-		return flatTerms.map((term) => ({
-			id: term.id,
-			name: term.name,
-			slug: term.slug,
-			label: term.label,
-			children: [],
-			count: counts.get(term.id) ?? 0
-		}));
-	});
-}
-/**
-* Get a single term by taxonomy and slug
-*/
-async function getTerm(taxonomyName, slug) {
-	const db = await getDb();
-	const row = await db.selectFrom("taxonomies").selectAll().where("name", "=", taxonomyName).where("slug", "=", slug).executeTakeFirst();
-	if (!row) return null;
-	const count = (await db.selectFrom("content_taxonomies").select((eb) => eb.fn.count("entry_id").as("count")).where("taxonomy_id", "=", row.id).executeTakeFirst())?.count ?? 0;
-	const children = (await db.selectFrom("taxonomies").selectAll().where("parent_id", "=", row.id).orderBy("label", "asc").execute()).map((child) => ({
-		id: child.id,
-		name: child.name,
-		slug: child.slug,
-		label: child.label,
-		parentId: child.parent_id ?? void 0,
-		children: []
-	}));
-	return {
-		id: row.id,
-		name: row.name,
-		slug: row.slug,
-		label: row.label,
-		parentId: row.parent_id ?? void 0,
-		description: row.data ? JSON.parse(row.data).description : void 0,
-		children,
-		count
-	};
-}
-/**
-* Get terms assigned to an entry
-*/
-function getEntryTerms(collection, entryId, taxonomyName) {
-	return requestCached(`terms:${collection}:${entryId}:${taxonomyName ?? "*"}`, async () => {
-		let query = (await getDb()).selectFrom("content_taxonomies").innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id").selectAll("taxonomies").where("content_taxonomies.collection", "=", collection).where("content_taxonomies.entry_id", "=", entryId);
-		if (taxonomyName) query = query.where("taxonomies.name", "=", taxonomyName);
-		return (await query.execute()).map((row) => ({
-			id: row.id,
-			name: row.name,
-			slug: row.slug,
-			label: row.label,
-			parentId: row.parent_id ?? void 0,
-			children: []
-		}));
-	});
-}
-/**
-* Get terms for multiple entries in a single query (batched API)
-*
-* This is more efficient than calling getEntryTerms for each entry
-* when you need terms for a list of entries.
-*
-* @param collection - The collection type (e.g., "posts")
-* @param entryIds - Array of entry IDs
-* @param taxonomyName - The taxonomy name (e.g., "categories")
-* @returns Map from entry ID to array of terms
-*/
-async function getTermsForEntries(collection, entryIds, taxonomyName) {
-	const result = /* @__PURE__ */ new Map();
-	const uniqueIds = [...new Set(entryIds)];
-	for (const id of uniqueIds) result.set(id, []);
-	if (uniqueIds.length === 0) return result;
-	const db = await getDb();
-	for (const chunk of chunks(uniqueIds, SQL_BATCH_SIZE)) {
-		let rows;
-		try {
-			rows = await db.selectFrom("content_taxonomies").innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id").select([
-				"content_taxonomies.entry_id",
-				"taxonomies.id",
-				"taxonomies.name",
-				"taxonomies.slug",
-				"taxonomies.label",
-				"taxonomies.parent_id"
-			]).where("content_taxonomies.collection", "=", collection).where("content_taxonomies.entry_id", "in", chunk).where("taxonomies.name", "=", taxonomyName).execute();
-		} catch (error) {
-			if (isMissingTableError(error)) return result;
-			throw error;
-		}
-		for (const row of rows) {
-			const entryId = row.entry_id;
-			const term = {
-				id: row.id,
-				name: row.name,
-				slug: row.slug,
-				label: row.label,
-				parentId: row.parent_id ?? void 0,
-				children: []
-			};
-			const terms = result.get(entryId);
-			if (terms) terms.push(term);
-		}
-	}
-	return result;
-}
-async function getAllTermsForEntries(collection, entryIds) {
-	const result = /* @__PURE__ */ new Map();
-	const uniqueIds = [...new Set(entryIds)];
-	for (const id of uniqueIds) result.set(id, {});
-	if (uniqueIds.length === 0) return result;
-	const db = await getDb();
-	const applicableTaxonomyNames = await getCollectionTaxonomyNames(collection);
-	for (const chunk of chunks(uniqueIds, SQL_BATCH_SIZE)) {
-		let rows;
-		try {
-			rows = await db.selectFrom("content_taxonomies").innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id").select([
-				"content_taxonomies.entry_id",
-				"taxonomies.id",
-				"taxonomies.name",
-				"taxonomies.slug",
-				"taxonomies.label",
-				"taxonomies.parent_id"
-			]).where("content_taxonomies.collection", "=", collection).where("content_taxonomies.entry_id", "in", chunk).orderBy("taxonomies.label", "asc").execute();
-		} catch (error) {
-			if (isMissingTableError(error)) {
-				for (const id of uniqueIds) primeEntryTermsCache(collection, id, {}, applicableTaxonomyNames);
-				return result;
-			}
-			throw error;
-		}
-		for (const row of rows) {
-			const entryId = row.entry_id;
-			const term = {
-				id: row.id,
-				name: row.name,
-				slug: row.slug,
-				label: row.label,
-				parentId: row.parent_id ?? void 0,
-				children: []
-			};
-			const byTaxonomy = result.get(entryId);
-			if (!byTaxonomy) continue;
-			const existing = byTaxonomy[row.name];
-			if (existing) existing.push(term);
-			else byTaxonomy[row.name] = [term];
-		}
-	}
-	for (const [entryId, byTaxonomy] of result) primeEntryTermsCache(collection, entryId, byTaxonomy, applicableTaxonomyNames);
-	return result;
-}
-async function getCollectionTaxonomyNames(collection) {
-	try {
-		return (await getTaxonomyDefs()).filter((def) => def.collections.includes(collection)).map((def) => def.name);
-	} catch (error) {
-		if (isMissingTableError(error)) return [];
-		throw error;
-	}
-}
-function primeEntryTermsCache(collection, entryId, byTaxonomy, applicableTaxonomyNames) {
-	for (const name of applicableTaxonomyNames) setRequestCacheEntry(`terms:${collection}:${entryId}:${name}`, byTaxonomy[name] ?? []);
-	for (const [name, terms] of Object.entries(byTaxonomy)) setRequestCacheEntry(`terms:${collection}:${entryId}:${name}`, terms);
-	setRequestCacheEntry(`terms:${collection}:${entryId}:*`, Object.values(byTaxonomy).flat());
-}
-/**
-* Get entries by term (wraps getDinewayCollection)
-*/
-async function getEntriesByTerm(collection, taxonomyName, termSlug) {
-	const { getDinewayCollection } = await import("./query-B9BO5goQ.mjs").then((n) => n.o);
-	const { entries } = await getDinewayCollection(collection, { where: { [taxonomyName]: termSlug } });
-	return entries;
-}
-/**
-* Build tree structure from flat terms
-*/
-function buildTree(flatTerms, counts) {
-	const map = /* @__PURE__ */ new Map();
-	const roots = [];
-	for (const term of flatTerms) map.set(term.id, {
-		id: term.id,
-		name: term.name,
-		slug: term.slug,
-		label: term.label,
-		parentId: term.parent_id ?? void 0,
-		description: term.data ? JSON.parse(term.data).description : void 0,
-		children: [],
-		count: counts.get(term.id) ?? 0
-	});
-	for (const term of map.values()) if (term.parentId && map.has(term.parentId)) map.get(term.parentId).children.push(term);
-	else roots.push(term);
-	return roots;
-}
-
-//#endregion
-export { getTaxonomyTerms as a, invalidateTermCache as c, getTaxonomyDefs as i, taxonomies_exports as l, getEntryTerms as n, getTerm as o, getTaxonomyDef as r, getTermsForEntries as s, getEntriesByTerm as t };