dineway 0.1.14 → 0.1.16

package/dist/taxonomies-BWmxbumf.mjs

@@ -0,0 +1,350 @@
+import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
+import { getRequestContext } from "./request-context.mjs";
+import { n as getI18nConfig, r as isI18nEnabled, t as getFallbackChain } from "./config-XW5tMrH8.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-vkrCT4Ta.mjs";
+import { n as requestCached, r as setRequestCacheEntry, t as peekRequestCache } from "./request-cache-DmVyQUBh.mjs";
+import { r as getDb } from "./loader-CQFxFOt1.mjs";
+import { t as isMissingTableError } from "./db-errors-BnUbfGsK.mjs";
+
+//#region src/i18n/resolve.ts
+/**
+* Shared locale-resolution helpers.
+*
+* An explicit locale wins, then the request-context locale, then the configured
+* defaultLocale when i18n is enabled. If none of those exist, callers should
+* treat the result as "do not filter by locale" for legacy single-locale sites.
+*/
+function resolveLocale(explicit) {
+	if (explicit !== void 0) return explicit;
+	const ctxLocale = getRequestContext()?.locale;
+	if (ctxLocale !== void 0) return ctxLocale;
+	const config = getI18nConfig();
+	if (config && isI18nEnabled()) return config.defaultLocale;
+}
+function resolveLocaleChain(explicit) {
+	const locale = resolveLocale(explicit);
+	if (locale === void 0) return [];
+	if (!isI18nEnabled()) return [locale];
+	return getFallbackChain(locale);
+}
+
+//#endregion
+//#region src/taxonomies/index.ts
+/**
+* Runtime API for taxonomies.
+*
+* Public helpers are locale-aware. Because `content_taxonomies.taxonomy_id`
+* stores a term translation_group, joins use `taxonomies.translation_group`
+* and optionally filter the requested locale.
+*/
+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 every taxonomy definition for the active locale.
+*/
+async function getTaxonomyDefs(options = {}) {
+	const locale = resolveLocale(options.locale);
+	return requestCached(`taxonomy-defs:${locale ?? "*"}`, async () => {
+		let query = (await getDb()).selectFrom("_dineway_taxonomy_defs").selectAll();
+		if (locale !== void 0) query = query.where("locale", "=", locale);
+		return (await query.execute()).map(rowToTaxonomyDef);
+	});
+}
+/**
+* Get a single taxonomy definition by name, following the locale fallback chain.
+*/
+async function getTaxonomyDef(name, options = {}) {
+	const chain = resolveLocaleChain(options.locale);
+	const allDefs = peekRequestCache(`taxonomy-defs:${resolveLocale(options.locale) ?? "*"}`);
+	if (allDefs) {
+		const defs = await allDefs;
+		if (chain.length === 0) return defs.find((def) => def.name === name) ?? null;
+		for (const locale of chain) {
+			const found = defs.find((def) => def.name === name && def.locale === locale);
+			if (found) return found;
+		}
+		return null;
+	}
+	return requestCached(`taxonomy-def:${name}:${chain.join(",")}`, async () => {
+		const db = await getDb();
+		if (chain.length === 0) {
+			const row = await db.selectFrom("_dineway_taxonomy_defs").selectAll().where("name", "=", name).orderBy("locale", "asc").executeTakeFirst();
+			return row ? rowToTaxonomyDef(row) : null;
+		}
+		for (const locale of chain) {
+			const row = await db.selectFrom("_dineway_taxonomy_defs").selectAll().where("name", "=", name).where("locale", "=", locale).executeTakeFirst();
+			if (row) return rowToTaxonomyDef(row);
+		}
+		return null;
+	});
+}
+/**
+* Get all terms for a taxonomy in the active locale.
+*/
+async function getTaxonomyTerms(taxonomyName, options = {}) {
+	const locale = resolveLocale(options.locale);
+	return requestCached(`taxonomy-terms:${taxonomyName}:${locale ?? "*"}`, async () => {
+		const db = await getDb();
+		const def = await getTaxonomyDef(taxonomyName, options);
+		if (!def) return [];
+		let termsQuery = db.selectFrom("taxonomies").selectAll().where("name", "=", taxonomyName).orderBy("label", "asc");
+		if (locale !== void 0) termsQuery = termsQuery.where("locale", "=", locale);
+		const rows = await termsQuery.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,
+			locale: row.locale,
+			translation_group: row.translation_group
+		}));
+		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.translation_group ?? term.id) ?? 0,
+			locale: term.locale,
+			translationGroup: term.translation_group
+		}));
+	});
+}
+/**
+* Get a single term by taxonomy and slug, following the locale fallback chain.
+*/
+async function getTerm(taxonomyName, slug, options = {}) {
+	const db = await getDb();
+	const chain = resolveLocaleChain(options.locale);
+	const selectTerm = () => db.selectFrom("taxonomies").selectAll().where("name", "=", taxonomyName).where("slug", "=", slug);
+	let row;
+	if (chain.length === 0) row = await selectTerm().orderBy("locale", "asc").executeTakeFirst();
+	else {
+		row = void 0;
+		for (const locale of chain) {
+			row = await selectTerm().where("locale", "=", locale).executeTakeFirst();
+			if (row) break;
+		}
+	}
+	if (!row) return null;
+	const count = (await db.selectFrom("content_taxonomies").select((eb) => eb.fn.count("entry_id").as("count")).where("taxonomy_id", "=", row.translation_group ?? row.id).executeTakeFirst())?.count ?? 0;
+	let childrenQuery = db.selectFrom("taxonomies").selectAll().where("parent_id", "=", row.id).orderBy("label", "asc");
+	if (row.locale) childrenQuery = childrenQuery.where("locale", "=", row.locale);
+	const children = (await childrenQuery.execute()).map((child) => ({
+		id: child.id,
+		name: child.name,
+		slug: child.slug,
+		label: child.label,
+		parentId: child.parent_id ?? void 0,
+		children: [],
+		locale: child.locale,
+		translationGroup: child.translation_group
+	}));
+	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,
+		locale: row.locale,
+		translationGroup: row.translation_group
+	};
+}
+/**
+* Get terms assigned to an entry, resolved into the active locale.
+*/
+function getEntryTerms(collection, entryId, taxonomyName, options = {}) {
+	const locale = resolveLocale(options.locale);
+	return requestCached(`terms:${collection}:${entryId}:${taxonomyName ?? "*"}:${locale ?? "*"}`, async () => {
+		let query = (await getDb()).selectFrom("content_taxonomies").innerJoin("taxonomies", "taxonomies.translation_group", "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);
+		if (locale !== void 0) query = query.where("taxonomies.locale", "=", locale);
+		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: [],
+			locale: row.locale,
+			translationGroup: row.translation_group
+		}));
+	});
+}
+/**
+* Get terms for multiple entries in one taxonomy.
+*/
+async function getTermsForEntries(collection, entryIds, taxonomyName, options = {}) {
+	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 locale = resolveLocale(options.locale);
+	for (const chunk of chunks(uniqueIds, SQL_BATCH_SIZE)) {
+		let rows;
+		try {
+			let query = db.selectFrom("content_taxonomies").innerJoin("taxonomies", "taxonomies.translation_group", "content_taxonomies.taxonomy_id").select([
+				"content_taxonomies.entry_id",
+				"taxonomies.id",
+				"taxonomies.name",
+				"taxonomies.slug",
+				"taxonomies.label",
+				"taxonomies.parent_id",
+				"taxonomies.locale",
+				"taxonomies.translation_group"
+			]).where("content_taxonomies.collection", "=", collection).where("content_taxonomies.entry_id", "in", chunk).where("taxonomies.name", "=", taxonomyName);
+			if (locale !== void 0) query = query.where("taxonomies.locale", "=", locale);
+			rows = await query.execute();
+		} catch (error) {
+			if (isMissingTableError(error)) return result;
+			throw error;
+		}
+		for (const row of rows) {
+			const term = {
+				id: row.id,
+				name: row.name,
+				slug: row.slug,
+				label: row.label,
+				parentId: row.parent_id ?? void 0,
+				children: [],
+				locale: row.locale,
+				translationGroup: row.translation_group
+			};
+			const terms = result.get(row.entry_id);
+			if (terms) terms.push(term);
+		}
+	}
+	return result;
+}
+/**
+* Batch-fetch terms for multiple entries across all taxonomies.
+*/
+async function getAllTermsForEntries(collection, entryIds, options = {}) {
+	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 locale = resolveLocale(options.locale);
+	const applicableTaxonomyNames = await getCollectionTaxonomyNames(collection, { locale });
+	for (const chunk of chunks(uniqueIds, SQL_BATCH_SIZE)) {
+		let rows;
+		try {
+			let query = db.selectFrom("content_taxonomies").innerJoin("taxonomies", "taxonomies.translation_group", "content_taxonomies.taxonomy_id").select([
+				"content_taxonomies.entry_id",
+				"taxonomies.id",
+				"taxonomies.name",
+				"taxonomies.slug",
+				"taxonomies.label",
+				"taxonomies.parent_id",
+				"taxonomies.locale",
+				"taxonomies.translation_group"
+			]).where("content_taxonomies.collection", "=", collection).where("content_taxonomies.entry_id", "in", chunk).orderBy("taxonomies.label", "asc");
+			if (locale !== void 0) query = query.where("taxonomies.locale", "=", locale);
+			rows = await query.execute();
+		} catch (error) {
+			if (isMissingTableError(error)) {
+				for (const id of uniqueIds) primeEntryTermsCache(collection, id, {}, applicableTaxonomyNames, locale);
+				return result;
+			}
+			throw error;
+		}
+		for (const row of rows) {
+			const term = {
+				id: row.id,
+				name: row.name,
+				slug: row.slug,
+				label: row.label,
+				parentId: row.parent_id ?? void 0,
+				children: [],
+				locale: row.locale,
+				translationGroup: row.translation_group
+			};
+			const byTaxonomy = result.get(row.entry_id);
+			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, locale);
+	return result;
+}
+async function getCollectionTaxonomyNames(collection, options) {
+	try {
+		return (await getTaxonomyDefs(options)).filter((def) => def.collections.includes(collection)).map((def) => def.name);
+	} catch (error) {
+		if (isMissingTableError(error)) return [];
+		throw error;
+	}
+}
+function primeEntryTermsCache(collection, entryId, byTaxonomy, applicableTaxonomyNames, locale) {
+	const localeKey = locale ?? "*";
+	for (const name of applicableTaxonomyNames) setRequestCacheEntry(`terms:${collection}:${entryId}:${name}:${localeKey}`, byTaxonomy[name] ?? []);
+	for (const [name, terms] of Object.entries(byTaxonomy)) setRequestCacheEntry(`terms:${collection}:${entryId}:${name}:${localeKey}`, terms);
+	setRequestCacheEntry(`terms:${collection}:${entryId}:*:${localeKey}`, Object.values(byTaxonomy).flat());
+}
+/**
+* Get entries by term.
+*/
+async function getEntriesByTerm(collection, taxonomyName, termSlug, options = {}) {
+	const { getDinewayCollection } = await import("./query-CWPxZjGM.mjs").then((n) => n.o);
+	const queryOptions = { where: { [taxonomyName]: termSlug } };
+	if (options.locale !== void 0) queryOptions.locale = options.locale;
+	const { entries } = await getDinewayCollection(collection, queryOptions);
+	return entries;
+}
+function rowToTaxonomyDef(row) {
+	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) : [],
+		locale: row.locale,
+		translationGroup: row.translation_group
+	};
+}
+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.translation_group ?? term.id) ?? 0,
+		locale: term.locale,
+		translationGroup: term.translation_group
+	});
+	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, resolveLocaleChain as d, getTaxonomyDefs as i, taxonomies_exports as l, getEntryTerms as n, getTerm as o, getTaxonomyDef as r, getTermsForEntries as s, getEntriesByTerm as t, resolveLocale as u };