dineway 0.2.40 → 0.2.41

package/dist/{taxonomies-lWGNLKgn.mjs → taxonomies-D5wO9zmB.mjs}

@@ -1,10 +1,10 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
 import { getRequestContext } from "./request-context.mjs";
-import { a as resetTaxonomyNamesCache, o as isMissingTableError, r as getDb } from "./loader-Dp6zLmQm.mjs";
-import { d as invalidateTaxonomyObjectCache, f as isObjectCacheActive, n as cachedQuery, t as CacheNamespace } from "./object-cache-mxCW-Rpt.mjs";
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-C8vSD_5L.mjs";
-import { i as setRequestCacheEntry, n as peekRequestCache, r as requestCached } from "./request-cache-8_ifFzVw.mjs";
-import { n as resolveLocaleChain, t as resolveLocale } from "./resolve-DEKC4qVa.mjs";
+import { a as resetTaxonomyNamesCache, o as isMissingTableError, r as getDb } from "./loader-CCwWFQSh.mjs";
+import { i as setRequestCacheEntry, n as peekRequestCache, r as requestCached } from "./request-cache-CizvDoxV.mjs";
+import { d as invalidateTaxonomyObjectCache, f as isObjectCacheActive, n as cachedQuery, t as CacheNamespace } from "./object-cache-DyI1SOBK.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-Bb56aCtB.mjs";
+import { n as resolveLocaleChain, t as resolveLocale } from "./resolve-BxFGSKYu.mjs";
 
 //#region src/taxonomies/index.ts
 /**
@@ -393,7 +393,7 @@ function primeFoldedEntryTerms(collection, perEntry, options = {}) {
 * Get entries by term.
 */
 async function getEntriesByTerm(collection, taxonomyName, termSlug, options = {}) {
-	const { getDinewayCollection } = await import("./query-xspvw7Ui.mjs").then((n) => n.o);
+	const { getDinewayCollection } = await import("./query-DDi367tF.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);

package/dist/{taxonomy-DN6i1upz.mjs → taxonomy-BK7JmHlo.mjs}

@@ -1,5 +1,9 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
-import { d as invalidateTaxonomyObjectCache } from "./object-cache-mxCW-Rpt.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
+import { atomicBatch } from "./database/batch.mjs";
+import { r as getContentStorage } from "./runtime-Ch5G-tnG.mjs";
+import { d as invalidateTaxonomyObjectCache } from "./object-cache-DyI1SOBK.mjs";
+import { r as snapshotContentTermChanges } from "./terms-EskuqbKE.mjs";
+import { sql } from "kysely";
 import { ulid } from "ulidx";
 
 //#region src/database/repositories/taxonomy.ts
@@ -120,9 +124,30 @@ var TaxonomyRepository = class {
 		if (deleted) invalidateTaxonomyObjectCache();
 		return deleted;
 	}
+	async writeRoutedTerms(collection, entryId, terms, checks = []) {
+		const { prepareContentWrite } = await import("./content-write-DAZCNKWl.mjs").then((n) => n.t);
+		const prepared = await prepareContentWrite(this.db, collection, {
+			id: entryId,
+			terms,
+			stageDraft: false
+		});
+		await atomicBatch(this.db, {
+			checks: [...prepared.batch.checks ?? [], ...checks],
+			statements: prepared.batch.statements
+		});
+		prepared.afterCommit();
+		invalidateTaxonomyObjectCache();
+	}
 	async attachToEntry(collection, entryId, taxonomyId) {
 		const group = await this.resolveTranslationGroup(taxonomyId);
 		if (!group) return;
+		if (getContentStorage(this.db, collection)) {
+			const source = await snapshotContentTermChanges(this.db, collection, entryId);
+			const term = (await this.findTranslations(group))[0];
+			if (!term || source.changes[term.name]?.includes(group)) return;
+			await this.writeRoutedTerms(collection, entryId, { [term.name]: [...source.changes[term.name] ?? [], group] }, source.checks);
+			return;
+		}
 		const row = {
 			collection,
 			entry_id: entryId,
@@ -134,6 +159,13 @@ var TaxonomyRepository = class {
 	async detachFromEntry(collection, entryId, taxonomyId) {
 		const group = await this.resolveTranslationGroup(taxonomyId);
 		if (!group) return;
+		if (getContentStorage(this.db, collection)) {
+			const source = await snapshotContentTermChanges(this.db, collection, entryId);
+			const term = (await this.findTranslations(group))[0];
+			if (!term || !source.changes[term.name]?.includes(group)) return;
+			await this.writeRoutedTerms(collection, entryId, { [term.name]: source.changes[term.name].filter((id) => id !== group) }, source.checks);
+			return;
+		}
 		await this.db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).where("taxonomy_id", "=", group).execute();
 		invalidateTaxonomyObjectCache();
 	}
@@ -153,6 +185,10 @@ var TaxonomyRepository = class {
 	* Term ids OR translation_groups are accepted and normalised to groups.
 	*/
 	async setTermsForEntry(collection, entryId, taxonomyName, termIds) {
+		if (getContentStorage(this.db, collection)) {
+			await this.writeRoutedTerms(collection, entryId, { [taxonomyName]: termIds });
+			return;
+		}
 		const groups = [];
 		for (const id of termIds) {
 			const group = await this.resolveTranslationGroup(id);
@@ -172,6 +208,12 @@ var TaxonomyRepository = class {
 		if (toRemove.length > 0 || toAdd.length > 0) invalidateTaxonomyObjectCache();
 	}
 	async clearEntryTerms(collection, entryId) {
+		if (getContentStorage(this.db, collection) && (await sql`SELECT id FROM ${sql.table(`ec_${collection}`)} WHERE id=${entryId}`.execute(this.db)).rows.length) {
+			const source = await snapshotContentTermChanges(this.db, collection, entryId);
+			const count = Object.values(source.changes).reduce((sum, ids) => sum + ids.length, 0);
+			if (count) await this.writeRoutedTerms(collection, entryId, Object.fromEntries(Object.keys(source.changes).map((name) => [name, []])), source.checks);
+			return count;
+		}
 		const result = await this.db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).executeTakeFirst();
 		const removed = Number(result.numDeletedRows ?? 0);
 		if (removed > 0) invalidateTaxonomyObjectCache();
@@ -183,6 +225,14 @@ var TaxonomyRepository = class {
 	* source's term assignments. Safe to call when the source has no terms.
 	*/
 	async copyEntryTerms(collection, sourceEntryId, targetEntryId) {
+		if (getContentStorage(this.db, collection)) {
+			const source = await snapshotContentTermChanges(this.db, collection, sourceEntryId);
+			const target = await snapshotContentTermChanges(this.db, collection, targetEntryId);
+			const changed = Object.entries(source.changes).filter(([name, ids]) => ids.some((id) => !target.changes[name]?.includes(id)));
+			if (!changed.length) return;
+			await this.writeRoutedTerms(collection, targetEntryId, Object.fromEntries(changed.map(([name, ids]) => [name, [...new Set([...target.changes[name] ?? [], ...ids])]])), [...source.checks, ...target.checks]);
+			return;
+		}
 		const rows = await this.db.selectFrom("content_taxonomies").select(["taxonomy_id"]).where("collection", "=", collection).where("entry_id", "=", sourceEntryId).execute();
 		if (rows.length === 0) return;
 		await this.db.insertInto("content_taxonomies").values(rows.map((r) => ({
@@ -226,7 +276,7 @@ var TaxonomyRepository = class {
 	*/
 	async countEntriesForTerms(translationGroups) {
 		if (translationGroups.length === 0) return /* @__PURE__ */ new Map();
-		const { chunks, SQL_BATCH_SIZE } = await import("./chunks-C8vSD_5L.mjs").then((n) => n.r);
+		const { chunks, SQL_BATCH_SIZE } = await import("./chunks-Bb56aCtB.mjs").then((n) => n.r);
 		const counts = /* @__PURE__ */ new Map();
 		for (const chunk of chunks(translationGroups, SQL_BATCH_SIZE)) {
 			const rows = await this.db.selectFrom("content_taxonomies").select(["taxonomy_id", (eb) => eb.fn.count("entry_id").as("count")]).where("taxonomy_id", "in", chunk).groupBy("taxonomy_id").execute();

package/dist/terms-EskuqbKE.mjs

@@ -0,0 +1,104 @@
+import { rowUnchanged } from "./database/batch.mjs";
+import { t as DinewayValidationError } from "./types-BI3ULB3A.mjs";
+import { sql } from "kysely";
+import { z } from "zod";
+
+//#region src/content-storage/terms.ts
+const contentTermChangesSchema = z.record(z.string().regex(/^[a-z][a-z0-9_]{0,62}$/), z.array(z.string().min(1).max(128)).max(100));
+async function snapshotContentTermChanges(db, collection, entryId) {
+	const rows = await db.selectFrom("content_taxonomies").selectAll().where("collection", "=", collection).where("entry_id", "=", entryId).execute();
+	const checks = [...rows.map((row) => rowUnchanged("content_taxonomies", row)), sql`(SELECT COUNT(*) FROM content_taxonomies WHERE collection = ${collection} AND entry_id = ${entryId}) = ${rows.length}`];
+	const changes = {};
+	for (const row of rows) {
+		const term = await db.selectFrom("taxonomies").selectAll().where("translation_group", "=", row.taxonomy_id).orderBy("locale").executeTakeFirst();
+		if (!term) throw new DinewayValidationError("An assigned term is missing.");
+		checks.push(rowUnchanged("taxonomies", term));
+		(changes[term.name] ??= []).push(row.taxonomy_id);
+	}
+	return {
+		changes,
+		checks
+	};
+}
+/** Prepare assignments together with content, so partition resolution sees the submitted terms. */
+async function prepareContentTerms(db, collection, entryId, input, locale) {
+	const changes = contentTermChangesSchema.parse(input);
+	const checks = [];
+	const statements = [];
+	const replaced = [];
+	const assignments = [];
+	for (const [name, ids] of Object.entries(changes)) {
+		const definitions = await db.selectFrom("_dineway_taxonomy_defs").selectAll().where("name", "=", name).execute();
+		if (!definitions.some((definition) => definition.collections === null || z.array(z.string()).parse(JSON.parse(definition.collections)).includes(collection))) throw new DinewayValidationError(`Taxonomy ${name} is not assigned to ${collection}.`);
+		checks.push(...definitions.map((definition) => rowUnchanged("_dineway_taxonomy_defs", definition)));
+		const groups = /* @__PURE__ */ new Set();
+		for (const id of new Set(ids)) {
+			const rows = await db.selectFrom("taxonomies").selectAll().where("name", "=", name).where((eb) => eb.or([eb("id", "=", id), eb("translation_group", "=", id)])).execute();
+			const term = rows.find((row) => row.locale === locale) ?? rows.find((row) => row.id === id);
+			if (!term?.translation_group) throw new DinewayValidationError(`Term ${id} is unavailable in taxonomy ${name}.`);
+			checks.push(rowUnchanged("taxonomies", term));
+			groups.add(term.translation_group);
+		}
+		const current = await db.selectFrom("content_taxonomies").selectAll().where("collection", "=", collection).where("entry_id", "=", entryId).where("taxonomy_id", "in", db.selectFrom("taxonomies").select("translation_group").where("name", "=", name)).execute();
+		replaced.push(...current.map((row) => row.taxonomy_id));
+		assignments.push(...groups);
+		checks.push(...current.map((row) => rowUnchanged("content_taxonomies", row)), sql`(SELECT COUNT(*) FROM content_taxonomies WHERE collection = ${collection} AND entry_id = ${entryId} AND taxonomy_id IN (SELECT translation_group FROM taxonomies WHERE name = ${name})) = ${current.length}`);
+		statements.push(db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).where("taxonomy_id", "in", db.selectFrom("taxonomies").select("translation_group").where("name", "=", name)).compile());
+		for (const group of groups) statements.push(db.insertInto("content_taxonomies").values({
+			collection,
+			entry_id: entryId,
+			taxonomy_id: group
+		}).onConflict((oc) => oc.doNothing()).compile());
+	}
+	return {
+		checks,
+		statements,
+		replaced,
+		assignments
+	};
+}
+async function snapshotPartitionTerms(db, collection, entryId, name, locale, selected) {
+	const checks = [];
+	const assignments = await db.selectFrom("content_taxonomies").selectAll().where("collection", "=", collection).where("entry_id", "=", entryId).execute();
+	checks.push(...assignments.map((row) => rowUnchanged("content_taxonomies", row)), sql`(SELECT COUNT(*) FROM content_taxonomies WHERE collection = ${collection} AND entry_id = ${entryId}) = ${assignments.length}`);
+	const ids = selected ?? assignments.map((row) => row.taxonomy_id);
+	const terms = [];
+	const seen = /* @__PURE__ */ new Set();
+	const ancestors = /* @__PURE__ */ new Set();
+	const visit = async (id, isSelected) => {
+		const rows = await db.selectFrom("taxonomies").selectAll().where("name", "=", name).where((eb) => eb.or([eb("id", "=", id), eb("translation_group", "=", id)])).execute();
+		const term = rows.find((row) => row.locale === locale) ?? rows.find((row) => row.id === id) ?? rows.toSorted((a, b) => a.locale.localeCompare(b.locale))[0];
+		if (!term?.translation_group) {
+			if (selected) throw new DinewayValidationError(`Partition term ${id} is missing from ${name}.`);
+			return;
+		}
+		if (ancestors.has(term.id)) throw new DinewayValidationError("Partition taxonomy contains a parent cycle.");
+		if (seen.has(term.id)) {
+			if (isSelected) terms.find((value) => value.id === term.id).selected = true;
+			return;
+		}
+		if (seen.size >= 100) throw new DinewayValidationError("Partition taxonomy exceeds 100 terms and ancestors.");
+		seen.add(term.id);
+		checks.push(rowUnchanged("taxonomies", term));
+		terms.push({
+			id: term.id,
+			group: term.translation_group,
+			name: term.name,
+			slug: term.slug,
+			parentId: term.parent_id,
+			selected: isSelected,
+			data: term.data ? z.record(z.string(), z.json()).parse(JSON.parse(term.data)) : null
+		});
+		ancestors.add(term.id);
+		if (term.parent_id) await visit(term.parent_id, false);
+		ancestors.delete(term.id);
+	};
+	for (const id of [...ids].toSorted()) await visit(id, true);
+	return {
+		terms,
+		checks
+	};
+}
+
+//#endregion
+export { snapshotPartitionTerms as i, prepareContentTerms as n, snapshotContentTermChanges as r, contentTermChangesSchema as t };

package/dist/text-extraction-CdqMGYQK.mjs

@@ -0,0 +1,96 @@
+import { toPlainText } from "@portabletext/toolkit";
+
+//#region src/search/text-extraction.ts
+/**
+* Text Extraction
+*
+* Extracts plain text from Portable Text blocks for FTS indexing.
+* Uses @portabletext/toolkit as base with extensions for custom block types.
+*/
+/**
+* Validate that a value looks like a Portable Text block array.
+* Each element must have at least a `_type` string property.
+*/
+function isPortableTextArray(value) {
+	return value.every((item) => typeof item === "object" && item !== null && "_type" in item && typeof item._type === "string");
+}
+/**
+* Extract additional text from custom block types that toPlainText doesn't handle
+*/
+function extractCustomBlockText(block) {
+	if (block._type === "code" && "code" in block && typeof block.code === "string") return block.code;
+	if (block._type === "image") {
+		const parts = [];
+		if ("alt" in block && typeof block.alt === "string" && block.alt) parts.push(block.alt);
+		if ("caption" in block && typeof block.caption === "string" && block.caption) parts.push(block.caption);
+		return parts.join(" ");
+	}
+	return "";
+}
+/**
+* Extract plain text from Portable Text blocks
+*
+* Uses @portabletext/toolkit's toPlainText for standard blocks,
+* plus extracts text from custom block types (code, images with alt/caption).
+*
+* @param blocks - Array of Portable Text blocks (or a JSON string)
+* @returns Plain text content
+*
+* @example
+* ```typescript
+* const text = extractPlainText([
+*   {
+*     _type: "block",
+*     _key: "abc",
+*     children: [{ _type: "span", _key: "s1", text: "Hello World" }]
+*   }
+* ]);
+* // Returns: "Hello World"
+* ```
+*/
+function extractPlainText(blocks) {
+	if (!blocks) return "";
+	let parsedBlocks;
+	if (typeof blocks === "string") try {
+		parsedBlocks = JSON.parse(blocks);
+	} catch {
+		return blocks;
+	}
+	else parsedBlocks = blocks;
+	if (!Array.isArray(parsedBlocks)) return "";
+	return [toPlainText(parsedBlocks.map((b) => {
+		const obj = { _type: b._type };
+		for (const [key, val] of Object.entries(b)) obj[key] = val;
+		return obj;
+	})), ...parsedBlocks.map(extractCustomBlockText).filter((text) => text.length > 0)].filter((t) => t.length > 0).join("\n");
+}
+/**
+* Extract searchable text from a content entry
+*
+* Extracts text from specified fields, handling both plain text and Portable Text.
+*
+* @param entry - Content entry data
+* @param fields - Field names to extract text from
+* @returns Object mapping field names to extracted text
+*/
+function extractSearchableFields(entry, fields) {
+	const result = {};
+	for (const field of fields) {
+		const value = entry[field];
+		if (value === null || value === void 0) {
+			result[field] = "";
+			continue;
+		}
+		if (typeof value === "string") if (value.startsWith("[")) result[field] = extractPlainText(value);
+		else result[field] = value;
+		else if (Array.isArray(value)) if (isPortableTextArray(value)) result[field] = extractPlainText(value);
+		else result[field] = JSON.stringify(value);
+		else if (typeof value === "object") result[field] = JSON.stringify(value);
+		else if (typeof value === "number" || typeof value === "boolean") result[field] = `${value}`;
+		else result[field] = "";
+	}
+	return result;
+}
+
+//#endregion
+export { extractSearchableFields as n, extractPlainText as t };

package/dist/{tokens-D-StaTAQ.mjs → tokens-D8HEH277.mjs}

@@ -1,4 +1,4 @@
-import { i as encodeBase64url, n as decodeBase64url } from "./base64-Cz-aU0X1.mjs";
+import { i as encodeBase64url, n as decodeBase64url } from "./base64-qvSs0Gxy.mjs";
 
 //#region src/preview/tokens.ts
 /**

package/dist/{trusted-proxy-hYufGFPK.mjs → trusted-proxy-Dg3U9Lrv.mjs}

@@ -1,4 +1,4 @@
-import { t as readRuntimeEnv } from "./runtime-env-CPTzh0mZ.mjs";
+import { t as readRuntimeEnv } from "./runtime-env-DpYGy4pT.mjs";
 
 //#region src/auth/trusted-proxy.ts
 /**

package/dist/{types-RFzE_V1M.mjs → types-BI3ULB3A.mjs}

@@ -1,5 +1,5 @@
-import { c as __exportAll } from "./runner-CRU7BXjr.mjs";
-import { r as encodeBase64, t as decodeBase64 } from "./base64-Cz-aU0X1.mjs";
+import { c as __exportAll } from "./runner-CuG8o1uW.mjs";
+import { r as encodeBase64, t as decodeBase64 } from "./base64-qvSs0Gxy.mjs";
 
 //#region src/database/repositories/types.ts
 var types_exports = /* @__PURE__ */ __exportAll({