emdash 0.40.0 → 0.40.1

package/dist/{apply-CoT603H3.mjs → apply-npY1TAhG.mjs}

@@ -3,10 +3,11 @@ import { o as resolveConfiguredLocale, r as getI18nConfig } from "./config-CvmjJ
 import { t as OptionsRepository } from "./options-DhrI7eMv.mjs";
 import { i as RevisionRepository, t as ContentRepository } from "./content-DFaIEDj9.mjs";
 import { r as coalesceObjectCacheWrites } from "./object-cache-CqWNY5uP.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-Dms7Uxbt.mjs";
 import { t as withTransaction } from "./transaction-BcJO4Tmc.mjs";
-import { t as MediaRepository } from "./media-Qp5S3eH3.mjs";
+import { t as MediaRepository } from "./media-CPXTbb1R.mjs";
 import { t as TaxonomyRepository } from "./taxonomy-C3Fu1YeH.mjs";
-import { t as RedirectRepository } from "./redirect-iJf5fltD.mjs";
+import { t as RedirectRepository } from "./redirect-B29UjdUn.mjs";
 import { t as BylineRepository } from "./byline-DYmkXqvo.mjs";
 import { t as INTERNAL_MEDIA_PREFIX } from "./normalize-CO2P8-iE.mjs";
 import { t as imageSize } from "./dist-BNwANFJR.mjs";
@@ -14,7 +15,7 @@ import { t as FTSManager } from "./fts-manager-S-K0laoS.mjs";
 import { d as findTaxonomyStructure, p as saveTaxonomyStructure } from "./loader-BzqeR1ZN.mjs";
 import { U as markContentMediaUsageCollectionStaleSafely, a as SchemaRegistry, t as BlockTypeRegistry } from "./block-type-registry-DUI_3KxT.mjs";
 import { i as resolveBlockTypes, r as normalizeBlocksData } from "./block-values-C_VIPr5t.mjs";
-import { c as setSiteSettings, s as invalidateSiteSettingsCache } from "./settings-CgjRWGW9.mjs";
+import { c as setSiteSettings, s as invalidateSiteSettingsCache } from "./settings-B4vDl1fK.mjs";
 import { a as ssrfSafeFetch, s as validateExternalUrl } from "./ssrf-CJUnJymJ.mjs";
 import { n as validateSeed, t as findTaxonomyStructureSource } from "./validate-CHosPEhs.mjs";
 import { ulid } from "ulidx";
@@ -131,7 +132,10 @@ function isRecord(value) {
 * This is the core implementation that bootstraps an EmDash site from a seed file.
 * Apply order is critical for foreign keys and references.
 */
-var apply_exports = /* @__PURE__ */ __exportAll({ applySeed: () => applySeed });
+var apply_exports = /* @__PURE__ */ __exportAll({
+	applySeed: () => applySeed,
+	applySeedWithinBudget: () => applySeedWithinBudget
+});
 async function applySiteSettings(db, settings, onConflict, result) {
 	const entries = Object.entries(settings).filter(([, value]) => value !== void 0);
 	if (entries.length === 0) return;
@@ -203,12 +207,59 @@ function isUntouchedBuiltInTaxonomyDef(def) {
 * @returns Result summary
 */
 async function applySeed(db, seed, options = {}) {
-	return coalesceObjectCacheWrites(() => applySeedWrites(db, seed, options));
+	const { result } = await coalesceObjectCacheWrites(() => applySeedWrites(db, seed, options, null));
+	return result;
 }
-async function applySeedWrites(db, seed, options) {
+/**
+* Apply a seed over several calls, for a platform that caps the queries or
+* fetches of one request.
+*
+* The limits are thresholds, checked before each taxonomy term, byline and
+* content entry is created and before the phases that follow content. Schema,
+* taxonomy definitions and settings are applied in every call, the item that
+* crosses a threshold finishes, and the phases after content (menus,
+* redirects, widgets, sections) run in one call, so set the limits well below
+* the platform's. A call that stops returns `complete: false`; applying the
+* same seed again continues with the first item not yet created. A call
+* creates at least one item before it stops, so repeated calls finish. A
+* `$media` URL used by entries in different calls is downloaded and stored
+* again, as a new media row, in each of those calls. Requires
+* `onConflict: "skip"`.
+*/
+async function applySeedWithinBudget(db, seed, options, limits) {
+	const budget = new SeedBudget(limits);
+	return coalesceObjectCacheWrites(() => applySeedWrites(db.withPlugin(budget), seed, options, budget));
+}
+/**
+* Counts what a budgeted call spends. As a Kysely plugin it sees every query
+* the call runs, including those inside transactions.
+*/
+var SeedBudget = class {
+	#queries = 0;
+	#mediaDownloads = 0;
+	constructor(limits) {
+		this.limits = limits;
+	}
+	transformQuery(args) {
+		this.#queries++;
+		return args.node;
+	}
+	transformResult(args) {
+		return Promise.resolve(args.result);
+	}
+	countMediaDownload() {
+		this.#mediaDownloads++;
+	}
+	isSpent() {
+		const { queries, mediaDownloads } = this.limits;
+		return queries !== void 0 && this.#queries >= queries || mediaDownloads !== void 0 && this.#mediaDownloads >= mediaDownloads;
+	}
+};
+async function applySeedWrites(db, seed, options, budget) {
 	const validation = validateSeed(seed);
 	if (!validation.valid) throw new Error(`Invalid seed file:\n${validation.errors.join("\n")}`);
 	const { includeContent = false, storage, skipMediaDownload = false, onConflict = "skip" } = options;
+	if (budget && onConflict !== "skip") throw new Error("A seed budget requires onConflict: \"skip\"");
 	const result = {
 		blockTypes: {
 			created: 0,
@@ -264,11 +315,18 @@ async function applySeedWrites(db, seed, options) {
 			skipped: 0
 		}
 	};
+	let complete = true;
+	const progress = {
+		done: 0,
+		total: countSeedItems(seed, includeContent)
+	};
+	const mayCreateItem = () => !budget || result.taxonomies.terms + result.bylines.created + result.content.created === 0 || !budget.isSpent();
 	const mediaContext = {
 		db,
 		storage: storage ?? null,
 		skipMediaDownload,
-		mediaCache: /* @__PURE__ */ new Map()
+		mediaCache: /* @__PURE__ */ new Map(),
+		budget
 	};
 	const seedIdMap = /* @__PURE__ */ new Map();
 	const seedBylineIdMap = /* @__PURE__ */ new Map();
@@ -441,21 +499,31 @@ async function applySeedWrites(db, seed, options) {
 			}
 			if (includeContent && taxonomy.terms && taxonomy.terms.length > 0) {
 				const termRepo = new TaxonomyRepository(db);
-				if (structure.hierarchical) await applyHierarchicalTerms(termRepo, taxonomy.name, defLocale, taxonomy.terms, termSeedIdMap, result, onConflict);
-				else for (const term of taxonomy.terms) {
+				const existingTerms = await findExistingSeedTerms(db, taxonomy.name, taxonomy.terms);
+				if (structure.hierarchical) {
+					const applied = await applyHierarchicalTerms(termRepo, taxonomy.name, defLocale, taxonomy.terms, existingTerms, termSeedIdMap, result, onConflict, mayCreateItem);
+					progress.done += applied.processed;
+					complete = applied.complete;
+				} else for (const term of taxonomy.terms) {
 					const termLocale = resolveConfiguredLocale(term.locale ?? defLocale);
-					const existing = await termRepo.findBySlug(taxonomy.name, term.slug, termLocale);
-					if (existing) {
+					const termKey = seedTermKey(termLocale, term.slug);
+					const existingId = existingTerms.get(termKey);
+					if (existingId) {
 						if (onConflict === "error") throw new Error(`Conflict: taxonomy term "${term.slug}" in "${taxonomy.name}" (${termLocale}) already exists`);
 						if (onConflict === "update") {
-							await termRepo.update(existing.id, {
+							await termRepo.update(existingId, {
 								label: term.label,
 								data: term.description ? { description: term.description } : {}
 							});
 							result.taxonomies.terms++;
 						}
-						if (term.id) termSeedIdMap.set(term.id, existing.id);
+						if (term.id) termSeedIdMap.set(term.id, existingId);
+						progress.done++;
 					} else {
+						if (!mayCreateItem()) {
+							complete = false;
+							break;
+						}
 						const translationOf = term.translationOf ? termSeedIdMap.get(term.translationOf) : void 0;
 						const created = await termRepo.create({
 							name: taxonomy.name,
@@ -465,25 +533,29 @@ async function applySeedWrites(db, seed, options) {
 							locale: termLocale,
 							translationOf
 						});
+						existingTerms.set(termKey, created.id);
 						if (term.id) termSeedIdMap.set(term.id, created.id);
 						result.taxonomies.terms++;
+						progress.done++;
 					}
 				}
 			}
+			if (!complete) break;
 		}
 		const { invalidateTaxonomyDefsCache } = await import("./taxonomies-C1IwNe8Q.mjs").then((n) => n.f);
 		invalidateTaxonomyDefsCache();
 	}
-	if (includeContent && seed.bylines) {
+	if (complete && includeContent && seed.bylines) {
 		const bylineRepo = new BylineRepository(db);
+		const existingBylines = await findExistingSeedBylines(db, seed.bylines.map((byline) => byline.slug));
 		for (const byline of seed.bylines) {
-			const existing = await bylineRepo.findBySlug(byline.slug);
-			if (existing) {
+			const existingId = existingBylines.get(byline.slug);
+			if (existingId) {
 				if (onConflict === "error") throw new Error(`Conflict: byline "${byline.slug}" already exists`);
 				if (onConflict === "update") {
 					const avatar = byline.avatar ? await resolveSeedBylineAvatar(db, byline.avatar) : null;
 					try {
-						if (!await bylineRepo.update(existing.id, {
+						if (!await bylineRepo.update(existingId, {
 							displayName: byline.displayName,
 							bio: byline.bio ?? null,
 							websiteUrl: byline.websiteUrl ?? null,
@@ -494,15 +566,21 @@ async function applySeedWrites(db, seed, options) {
 						if (avatar?.created) await deleteMediaRow(db, avatar.id);
 						throw error;
 					}
-					seedBylineIdMap.set(byline.id, existing.id);
+					seedBylineIdMap.set(byline.id, existingId);
 					result.bylines.updated++;
 					if (avatar?.created) result.media.created++;
+					progress.done++;
 					continue;
 				}
-				seedBylineIdMap.set(byline.id, existing.id);
+				seedBylineIdMap.set(byline.id, existingId);
 				result.bylines.skipped++;
+				progress.done++;
 				continue;
 			}
+			if (!mayCreateItem()) {
+				complete = false;
+				break;
+			}
 			const avatar = byline.avatar ? await resolveSeedBylineAvatar(db, byline.avatar) : null;
 			let createdId;
 			try {
@@ -518,12 +596,14 @@ async function applySeedWrites(db, seed, options) {
 				if (avatar?.created) await deleteMediaRow(db, avatar.id);
 				throw error;
 			}
+			existingBylines.set(byline.slug, createdId);
 			seedBylineIdMap.set(byline.id, createdId);
 			result.bylines.created++;
 			if (avatar?.created) result.media.created++;
+			progress.done++;
 		}
 	}
-	if (includeContent && seed.content) {
+	if (complete && includeContent && seed.content) {
 		const contentRepo = new ContentRepository(db);
 		const schemaRegistry = new SchemaRegistry(db);
 		const datetimeContexts = /* @__PURE__ */ new Map();
@@ -532,10 +612,11 @@ async function applySeedWrites(db, seed, options) {
 				const collectionInfo = await schemaRegistry.getCollectionWithFields(collectionSlug);
 				const collectionRoutable = collectionInfo?.routable !== false;
 				const resolvedBlockTypes = collectionInfo?.fields.some((field) => field.type === "blocks") ? await resolveBlockTypes(db) : void 0;
+				const existingEntries = await findExistingSeedEntries(contentRepo, collectionSlug, entries, defaultLocale);
 				for (const entry of entries) {
-					const entrySlug = typeof entry.slug === "string" && entry.slug.trim().length > 0 ? entry.slug : null;
-					const entryLocale = resolveConfiguredLocale(entry.locale ?? defaultLocale);
-					const existing = entrySlug ? await contentRepo.findBySlug(collectionSlug, entrySlug, entryLocale) : await contentRepo.findById(collectionSlug, entry.id);
+					const { slug: entrySlug, locale: entryLocale } = seedEntryIdentity(entry, defaultLocale);
+					const entryKey = seedEntryKey(entry, entrySlug, entryLocale);
+					const existing = existingEntries.get(entryKey);
 					if (existing) {
 						if (onConflict === "error") throw new Error(`Conflict: content "${entrySlug ?? entry.id}" in "${collectionSlug}" already exists`);
 						if (onConflict === "update") {
@@ -580,13 +661,19 @@ async function applySeedWrites(db, seed, options) {
 							}
 							seedIdMap.set(entry.id, existing.id);
 							result.content.updated++;
+							progress.done++;
 							await markSeedContentCollectionStale(collectionSlug);
 							continue;
 						}
 						result.content.skipped++;
 						seedIdMap.set(entry.id, existing.id);
+						progress.done++;
 						continue;
 					}
+					if (!mayCreateItem()) {
+						complete = false;
+						break;
+					}
 					let resolvedData = await resolveReferences(entry.data, seedIdMap, mediaContext, result);
 					if (collectionInfo) resolvedData = await normalizeBlocksData(db, collectionInfo, resolvedData, {}, { restoreBlocks: true }, false, resolvedBlockTypes);
 					let translationOf;
@@ -623,14 +710,26 @@ async function applySeedWrites(db, seed, options) {
 						throw error;
 					}
 					seedIdMap.set(entry.id, created.id);
+					existingEntries.set(entryKey, created);
 					result.content.created++;
+					progress.done++;
 					await markSeedContentCollectionStale(collectionSlug);
 				}
+				if (!complete) break;
 			}
 		} finally {
 			await retryFailedSeedContentStaleMarks();
 		}
 	}
+	if (complete && !mayCreateItem()) complete = false;
+	if (!complete) {
+		await invalidateSeedCaches();
+		return {
+			result,
+			complete,
+			progress
+		};
+	}
 	if (seed.menus) {
 		const menuSeedIdMap = /* @__PURE__ */ new Map();
 		const itemSeedIdMap = /* @__PURE__ */ new Map();
@@ -767,18 +866,110 @@ async function applySeedWrites(db, seed, options) {
 			}
 		}
 	}
+	await invalidateSeedCaches();
+	return {
+		result,
+		complete,
+		progress
+	};
+}
+function countSeedItems(seed, includeContent) {
+	if (!includeContent) return 0;
+	const terms = (seed.taxonomies ?? []).reduce((total, taxonomy) => total + (taxonomy.terms?.length ?? 0), 0);
+	const entries = Object.values(seed.content ?? {}).reduce((total, collectionEntries) => total + collectionEntries.length, 0);
+	return terms + (seed.bylines?.length ?? 0) + entries;
+}
+function seedTermKey(locale, slug) {
+	return `${locale}::${slug}`;
+}
+/**
+* Find which of a taxonomy's seed terms already exist, as term ids keyed by
+* `seedTermKey`. Each query covers a batch of slugs.
+*/
+async function findExistingSeedTerms(db, taxonomyName, terms) {
+	const existing = /* @__PURE__ */ new Map();
+	for (const batch of chunks([...new Set(terms.map((term) => term.slug))], SQL_BATCH_SIZE)) {
+		const rows = await db.selectFrom("taxonomies").select([
+			"id",
+			"slug",
+			"locale"
+		]).where("name", "=", taxonomyName).where("slug", "in", batch).execute();
+		for (const row of rows) existing.set(seedTermKey(row.locale, row.slug), row.id);
+	}
+	return existing;
+}
+/**
+* Find which seed bylines already exist, as byline ids keyed by slug. A slug
+* in several locales resolves to the lowest locale code, as
+* `BylineRepository.findBySlug` does. Each query covers a batch of slugs.
+*/
+async function findExistingSeedBylines(db, slugs) {
+	const existing = /* @__PURE__ */ new Map();
+	for (const batch of chunks([...new Set(slugs)], SQL_BATCH_SIZE)) {
+		const rows = await db.selectFrom("_emdash_bylines").select(["id", "slug"]).where("slug", "in", batch).orderBy("locale", "asc").execute();
+		for (const row of rows) if (!existing.has(row.slug)) existing.set(row.slug, row.id);
+	}
+	return existing;
+}
+/**
+* Invalidate caches that may have been affected by seed data.
+* Seed creates bylines, redirects, and collections, all of which
+* have module-level caches in the hot path.
+*/
+async function invalidateSeedCaches() {
 	const { invalidateBylineCache } = await import("./bylines-BPwJqoYH.mjs").then((n) => n.t);
 	const { invalidateRedirectCache } = await import("./cache-m7UEkRFV.mjs").then((n) => n.t);
 	const { invalidateUrlPatternCache } = await import("./query-B48peoRT.mjs").then((n) => n.o);
 	invalidateBylineCache();
 	invalidateRedirectCache();
 	invalidateUrlPatternCache();
-	return result;
+}
+function seedEntryIdentity(entry, defaultLocale) {
+	return {
+		slug: typeof entry.slug === "string" && entry.slug.trim().length > 0 ? entry.slug : null,
+		locale: resolveConfiguredLocale(entry.locale ?? defaultLocale)
+	};
 }
 /**
-* Apply hierarchical taxonomy terms (parents before children)
+* Slugful entries use the existing locale-aware key. Slugless seed entries
+* persist their seed ID, which keeps re-application idempotent.
 */
-async function applyHierarchicalTerms(termRepo, taxonomyName, defLocale, terms, termSeedIdMap, result, onConflict = "skip") {
+function seedEntryKey(entry, slug, locale) {
+	return slug === null ? `id:${entry.id}` : `slug:${locale}:${slug}`;
+}
+/**
+* Find which of a collection's seed entries already exist, keyed by
+* `seedEntryKey`. Each query covers a batch of entries.
+*/
+async function findExistingSeedEntries(repo, collectionSlug, entries, defaultLocale) {
+	const identities = entries.map((entry) => ({
+		entry,
+		...seedEntryIdentity(entry, defaultLocale)
+	}));
+	const slugsByLocale = /* @__PURE__ */ new Map();
+	for (const { slug, locale } of identities) {
+		if (slug === null) continue;
+		const slugs = slugsByLocale.get(locale);
+		if (slugs) slugs.push(slug);
+		else slugsByLocale.set(locale, [slug]);
+	}
+	const bySlug = /* @__PURE__ */ new Map();
+	for (const [locale, slugs] of slugsByLocale) bySlug.set(locale, await repo.findManyBySlugsInLocale(collectionSlug, slugs, locale));
+	const byId = await repo.findManyByIds(collectionSlug, identities.filter(({ slug }) => slug === null).map(({ entry }) => entry.id));
+	const existing = /* @__PURE__ */ new Map();
+	for (const { entry, slug, locale } of identities) {
+		const item = slug === null ? byId.get(entry.id) : bySlug.get(locale)?.get(slug);
+		if (item) existing.set(seedEntryKey(entry, slug, locale), item);
+	}
+	return existing;
+}
+/**
+* Apply hierarchical taxonomy terms (parents before children). Stops before
+* creating a term once `mayCreate` returns false, and returns how many terms
+* were found or created.
+*/
+async function applyHierarchicalTerms(termRepo, taxonomyName, defLocale, terms, existingTerms, termSeedIdMap, result, onConflict, mayCreate) {
+	let processed = 0;
 	const slugToId = /* @__PURE__ */ new Map();
 	const resolveTermLocale = (term) => resolveConfiguredLocale(term.locale ?? defLocale);
 	let remaining = [...terms];
@@ -792,20 +983,25 @@ async function applyHierarchicalTerms(termRepo, taxonomyName, defLocale, terms,
 			if (!parentReady || !translationReady) continue;
 			const parentId = term.parent ? slugToId.get(`${termLocale}::${term.parent}`) : void 0;
 			const translationOf = term.translationOf ? termSeedIdMap.get(term.translationOf) : void 0;
-			const existing = await termRepo.findBySlug(taxonomyName, term.slug, termLocale);
-			if (existing) {
+			const termKey = seedTermKey(termLocale, term.slug);
+			const existingId = existingTerms.get(termKey);
+			if (existingId) {
 				if (onConflict === "error") throw new Error(`Conflict: taxonomy term "${term.slug}" in "${taxonomyName}" (${termLocale}) already exists`);
 				if (onConflict === "update") {
-					await termRepo.update(existing.id, {
+					await termRepo.update(existingId, {
 						label: term.label,
 						parentId,
 						data: term.description ? { description: term.description } : {}
 					});
 					result.taxonomies.terms++;
 				}
-				slugToId.set(`${termLocale}::${term.slug}`, existing.id);
-				if (term.id) termSeedIdMap.set(term.id, existing.id);
+				slugToId.set(termKey, existingId);
+				if (term.id) termSeedIdMap.set(term.id, existingId);
 			} else {
+				if (!mayCreate()) return {
+					processed,
+					complete: false
+				};
 				const created = await termRepo.create({
 					name: taxonomyName,
 					slug: term.slug,
@@ -815,16 +1011,22 @@ async function applyHierarchicalTerms(termRepo, taxonomyName, defLocale, terms,
 					locale: termLocale,
 					translationOf
 				});
-				slugToId.set(`${termLocale}::${term.slug}`, created.id);
+				existingTerms.set(termKey, created.id);
+				slugToId.set(termKey, created.id);
 				if (term.id) termSeedIdMap.set(term.id, created.id);
 				result.taxonomies.terms++;
 			}
+			processed++;
 			processedThisPass.push(term.slug + "::" + termLocale);
 		}
 		remaining = remaining.filter((term) => !processedThisPass.includes(term.slug + "::" + resolveTermLocale(term)));
 		maxPasses--;
 	}
 	if (remaining.length > 0) console.warn(`Could not process ${remaining.length} terms due to missing parents/translations`);
+	return {
+		processed,
+		complete: true
+	};
 }
 /**
 * Apply byline credits to a content entry.
@@ -1057,6 +1259,7 @@ async function resolveMedia(ref, ctx, result) {
 	try {
 		validateExternalUrl(url);
 		console.log(`  📥 Downloading: ${url}`);
+		ctx.budget?.countMediaDownload();
 		const response = await ssrfSafeFetch(url, { headers: { "User-Agent": "EmDash-CMS/1.0" } });
 		if (!response.ok) {
 			console.warn(`  ⚠️ Failed to download ${url}: ${response.status}`);
@@ -1159,5 +1362,5 @@ function getImageDimensions(buffer) {
 }
 
 //#endregion
-export { createPublicMediaUrlResolver as a, sanitizeGalleryImages as i, apply_exports as n, resolveImageMedia as r, applySeed as t };
-//# sourceMappingURL=apply-CoT603H3.mjs.map
+export { sanitizeGalleryImages as a, resolveImageMedia as i, applySeedWithinBudget as n, createPublicMediaUrlResolver as o, apply_exports as r, applySeed as t };
+//# sourceMappingURL=apply-npY1TAhG.mjs.map