dineway 0.1.44 → 0.1.46

package/dist/byline-CXQcMsBu.mjs

@@ -0,0 +1,628 @@
+import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { l as listTablesLike } from "./dialect-helpers-fk43GbDb.mjs";
+import { n as decodeCursor, r as encodeCursor, t as DinewayValidationError } from "./types-Ck7-WoUD.mjs";
+import { t as withTransaction } from "./transaction-D0FOsb3X.mjs";
+import { getRequestContext } from "./request-context.mjs";
+import { i as setRequestCacheEntry, n as peekRequestCache, r as requestCached, t as clearRequestCacheEntry } from "./request-cache-w5cj5itT.mjs";
+import { n as BylineSchemaRegistry } from "./byline-registry-CL8BxPPp.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-DgEw12Bc.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+
+//#region src/bylines/field-defs-cache.ts
+const HOLDER_KEY = Symbol.for("dineway:byline-field-defs");
+const REQUEST_CACHE_KEY_VERSION = "byline-fields-version";
+const REQUEST_CACHE_KEY_DEFS_PREFIX = "byline-field-defs:";
+function getHolder() {
+	const existing = Reflect.get(globalThis, HOLDER_KEY);
+	if (isFieldDefsHolder(existing)) return existing;
+	const holder = {
+		cached: null,
+		cachedVersion: -1
+	};
+	Reflect.set(globalThis, HOLDER_KEY, holder);
+	return holder;
+}
+function isFieldDefsHolder(value) {
+	if (value && typeof value === "object" && "cached" in value && "cachedVersion" in value) return (value.cached === null || value.cached instanceof Promise) && typeof value.cachedVersion === "number";
+	return false;
+}
+const holder = getHolder();
+async function getBylineFieldsVersion(db) {
+	return requestCached(REQUEST_CACHE_KEY_VERSION, () => new BylineSchemaRegistry(db).getVersion());
+}
+async function getBylineFieldDefs(db) {
+	const hasDbOverride = !!getRequestContext()?.db;
+	const version = await getBylineFieldsVersion(db);
+	const dirty = version % 2 !== 0;
+	return requestCached(`${REQUEST_CACHE_KEY_DEFS_PREFIX}${version}`, async () => {
+		if (hasDbOverride || dirty) return new BylineSchemaRegistry(db).listFields();
+		if (!dirty && holder.cached !== null && holder.cachedVersion === version) return holder.cached;
+		const defs = new BylineSchemaRegistry(db).listFields();
+		if (!dirty) {
+			holder.cached = defs;
+			holder.cachedVersion = version;
+		}
+		try {
+			return await defs;
+		} catch (error) {
+			if (holder.cached === defs) {
+				holder.cached = null;
+				holder.cachedVersion = -1;
+			}
+			throw error;
+		}
+	});
+}
+
+//#endregion
+//#region src/database/repositories/byline.ts
+function rowToByline(row) {
+	return {
+		id: row.id,
+		slug: row.slug,
+		displayName: row.display_name,
+		bio: row.bio,
+		avatarMediaId: row.avatar_media_id,
+		avatarStorageKey: row.avatar_storage_key ?? null,
+		avatarAlt: row.avatar_alt ?? null,
+		websiteUrl: row.website_url,
+		userId: row.user_id,
+		isGuest: row.is_guest === 1,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		locale: row.locale,
+		translationGroup: row.translation_group,
+		customFields: {}
+	};
+}
+function assignCustomFieldValue(summary, field, stored) {
+	const target = summary.customFields ?? {};
+	if (stored === null) target[field.slug] = null;
+	else {
+		let parsed;
+		try {
+			parsed = JSON.parse(stored);
+		} catch {
+			console.warn(`[BylineRepository] dropping malformed JSON for byline=${summary.id} field=${field.slug}`);
+			return;
+		}
+		if (!isCustomFieldValue(parsed)) {
+			console.warn(`[BylineRepository] dropping invalid JSON value for byline=${summary.id} field=${field.slug}`);
+			return;
+		}
+		target[field.slug] = parsed;
+	}
+	summary.customFields = target;
+}
+function isCustomFieldValue(value) {
+	return value === null || typeof value === "string" || typeof value === "boolean";
+}
+function coerceFieldValue(field, raw) {
+	if (raw === null) return null;
+	switch (field.type) {
+		case "string":
+		case "text":
+			if (typeof raw !== "string") throw new DinewayValidationError(`Byline field "${field.slug}" expects a string value`, {
+				slug: field.slug,
+				type: field.type,
+				received: typeof raw
+			});
+			return raw;
+		case "url": {
+			if (typeof raw !== "string") throw new DinewayValidationError(`Byline field "${field.slug}" expects a string value`, {
+				slug: field.slug,
+				type: field.type,
+				received: typeof raw
+			});
+			if (raw === "") return null;
+			let parsed;
+			try {
+				parsed = new URL(raw);
+			} catch {
+				throw new DinewayValidationError(`Byline field "${field.slug}" expects a valid URL`, {
+					slug: field.slug,
+					type: field.type,
+					received: raw
+				});
+			}
+			if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new DinewayValidationError(`Byline field "${field.slug}" must use http or https scheme`, {
+				slug: field.slug,
+				type: field.type,
+				received: raw,
+				protocol: parsed.protocol
+			});
+			return raw;
+		}
+		case "boolean":
+			if (typeof raw !== "boolean") throw new DinewayValidationError(`Byline field "${field.slug}" expects a boolean value`, {
+				slug: field.slug,
+				type: field.type,
+				received: typeof raw
+			});
+			return raw;
+		case "select": {
+			if (typeof raw !== "string") throw new DinewayValidationError(`Byline field "${field.slug}" expects a string value`, {
+				slug: field.slug,
+				type: field.type,
+				received: typeof raw
+			});
+			const options = field.validation?.options ?? [];
+			if (!options.includes(raw)) throw new DinewayValidationError(`Byline field "${field.slug}" value "${raw}" is not one of the registered choices`, {
+				slug: field.slug,
+				value: raw,
+				options
+			});
+			return raw;
+		}
+	}
+}
+var BylineRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async withCustomFields(rows) {
+		const summaries = rows.map(rowToByline);
+		await this.hydrateBylineCustomFields(summaries);
+		return summaries;
+	}
+	async hydrateBylineCustomFields(summaries) {
+		for (const summary of summaries) summary.customFields = {};
+		await this.applyCustomFieldsTo(summaries);
+	}
+	async applyCustomFieldsTo(summaries) {
+		if (summaries.length === 0) return;
+		const defs = await getBylineFieldDefs(this.db);
+		if (defs.length === 0) return;
+		const fieldById = new Map(defs.map((field) => [field.id, field]));
+		const translatableByByline = /* @__PURE__ */ new Map();
+		const bylineIds = [...new Set(summaries.map((summary) => summary.id))];
+		for (const chunk of chunks(bylineIds, SQL_BATCH_SIZE)) {
+			const rows = await this.db.selectFrom("_dineway_byline_field_values").select([
+				"byline_id",
+				"field_id",
+				"value"
+			]).where("byline_id", "in", chunk).execute();
+			for (const row of rows) {
+				let fieldMap = translatableByByline.get(row.byline_id);
+				if (!fieldMap) {
+					fieldMap = /* @__PURE__ */ new Map();
+					translatableByByline.set(row.byline_id, fieldMap);
+				}
+				fieldMap.set(row.field_id, row.value);
+			}
+		}
+		const groups = [...new Set(summaries.map((summary) => summary.translationGroup).filter((group) => typeof group === "string" && group.length > 0))];
+		const groupByGroup = await this.loadGroupValuesByIds(groups);
+		for (const summary of summaries) {
+			const translatableValues = translatableByByline.get(summary.id);
+			if (translatableValues) for (const [fieldId, value] of translatableValues) {
+				const field = fieldById.get(fieldId);
+				if (!field || !field.translatable) continue;
+				assignCustomFieldValue(summary, field, value);
+			}
+			if (!summary.translationGroup) continue;
+			const groupValues = groupByGroup.get(summary.translationGroup);
+			if (!groupValues) continue;
+			for (const [fieldId, value] of groupValues) {
+				const field = fieldById.get(fieldId);
+				if (!field || field.translatable) continue;
+				assignCustomFieldValue(summary, field, value);
+			}
+		}
+	}
+	async loadGroupValuesByIds(groups) {
+		const result = /* @__PURE__ */ new Map();
+		if (groups.length === 0) return result;
+		const missing = [];
+		for (const group of groups) {
+			const cached = peekRequestCache(`byline-field-group-values:${group}`);
+			if (cached) result.set(group, await cached);
+			else missing.push(group);
+		}
+		if (missing.length === 0) return result;
+		const fetched = /* @__PURE__ */ new Map();
+		for (const group of missing) fetched.set(group, /* @__PURE__ */ new Map());
+		for (const chunk of chunks(missing, SQL_BATCH_SIZE)) {
+			const rows = await this.db.selectFrom("_dineway_byline_field_group_values").select([
+				"translation_group",
+				"field_id",
+				"value"
+			]).where("translation_group", "in", chunk).execute();
+			for (const row of rows) fetched.get(row.translation_group)?.set(row.field_id, row.value);
+		}
+		for (const group of missing) {
+			const values = fetched.get(group);
+			if (!values) continue;
+			setRequestCacheEntry(`byline-field-group-values:${group}`, values);
+			result.set(group, values);
+		}
+		return result;
+	}
+	async resolveCustomFieldWrites(customFields) {
+		if (!customFields || Object.keys(customFields).length === 0) return [];
+		const defs = await getBylineFieldDefs(this.db);
+		const bySlug = new Map(defs.map((field) => [field.slug, field]));
+		const writes = [];
+		for (const [slug, raw] of Object.entries(customFields)) {
+			const field = bySlug.get(slug);
+			if (!field) throw new DinewayValidationError(`Unknown byline custom field "${slug}"`, {
+				slug,
+				registered: defs.map((item) => item.slug)
+			});
+			writes.push({
+				field,
+				value: coerceFieldValue(field, raw)
+			});
+		}
+		return writes;
+	}
+	async writeCustomFields(trx, bylineId, translationGroup, writes, now) {
+		let touchedGroupShared = false;
+		for (const { field, value } of writes) {
+			if (!field.translatable) touchedGroupShared = true;
+			if (field.translatable) {
+				if (value === null) {
+					await trx.deleteFrom("_dineway_byline_field_values").where("byline_id", "=", bylineId).where("field_id", "=", field.id).execute();
+					continue;
+				}
+				const encoded = JSON.stringify(value);
+				await trx.insertInto("_dineway_byline_field_values").values({
+					byline_id: bylineId,
+					field_id: field.id,
+					value: encoded,
+					created_at: now,
+					updated_at: now
+				}).onConflict((oc) => oc.columns(["byline_id", "field_id"]).doUpdateSet({
+					value: encoded,
+					updated_at: now
+				})).execute();
+				continue;
+			}
+			if (value === null) {
+				await trx.deleteFrom("_dineway_byline_field_group_values").where("translation_group", "=", translationGroup).where("field_id", "=", field.id).execute();
+				continue;
+			}
+			const encoded = JSON.stringify(value);
+			await trx.insertInto("_dineway_byline_field_group_values").values({
+				translation_group: translationGroup,
+				field_id: field.id,
+				value: encoded,
+				created_at: now,
+				updated_at: now
+			}).onConflict((oc) => oc.columns(["translation_group", "field_id"]).doUpdateSet({
+				value: encoded,
+				updated_at: now
+			})).execute();
+		}
+		return touchedGroupShared;
+	}
+	async findById(id) {
+		const row = await this.db.selectFrom("_dineway_bylines").selectAll().where("id", "=", id).executeTakeFirst();
+		if (!row) return null;
+		return (await this.withCustomFields([row]))[0] ?? null;
+	}
+	async findBySlug(slug, options) {
+		let query = this.db.selectFrom("_dineway_bylines").selectAll().where("slug", "=", slug);
+		if (options?.locale !== void 0) query = query.where("locale", "=", options.locale);
+		const row = await query.orderBy("locale", "asc").executeTakeFirst();
+		if (!row) return null;
+		return (await this.withCustomFields([row]))[0] ?? null;
+	}
+	async findByUserId(userId, options) {
+		let query = this.db.selectFrom("_dineway_bylines").selectAll().where("user_id", "=", userId);
+		if (options?.locale !== void 0) query = query.where("locale", "=", options.locale);
+		const row = await query.orderBy("locale", "asc").executeTakeFirst();
+		if (!row) return null;
+		return (await this.withCustomFields([row]))[0] ?? null;
+	}
+	async findMany(options) {
+		const limit = Math.min(Math.max(options?.limit ?? 50, 1), 100);
+		let query = this.db.selectFrom("_dineway_bylines").selectAll().orderBy("created_at", "desc").orderBy("id", "desc").limit(limit + 1);
+		if (options?.search) {
+			const term = `%${options.search.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_")}%`;
+			query = query.where((eb) => eb.or([eb("display_name", "like", term), eb("slug", "like", term)]));
+		}
+		if (options?.isGuest !== void 0) query = query.where("is_guest", "=", options.isGuest ? 1 : 0);
+		if (options?.userId !== void 0) query = query.where("user_id", "=", options.userId);
+		if (options?.locale !== void 0) query = query.where("locale", "=", options.locale);
+		if (options?.cursor) {
+			const decoded = decodeCursor(options.cursor);
+			if (decoded) query = query.where((eb) => eb.or([eb("created_at", "<", decoded.orderValue), eb.and([eb("created_at", "=", decoded.orderValue), eb("id", "<", decoded.id)])]));
+		}
+		const rows = await query.execute();
+		const items = await this.withCustomFields(rows.slice(0, limit));
+		const result = { items };
+		if (rows.length > limit) {
+			const last = items.at(-1);
+			if (last) result.nextCursor = encodeCursor(last.createdAt, last.id);
+		}
+		return result;
+	}
+	async listTranslations(id) {
+		const anchor = await this.findById(id);
+		if (!anchor) return [];
+		const group = anchor.translationGroup ?? anchor.id;
+		return this.findByTranslationGroup(group);
+	}
+	async findByTranslationGroup(translationGroup) {
+		const rows = await this.db.selectFrom("_dineway_bylines").selectAll().where("translation_group", "=", translationGroup).orderBy("locale", "asc").execute();
+		return this.withCustomFields(rows);
+	}
+	async create(input) {
+		const id = ulid();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const customFieldWrites = await this.resolveCustomFieldWrites(input.customFields);
+		let translationGroup = id;
+		if (input.translationOf) {
+			const source = await this.findById(input.translationOf);
+			if (!source) throw new Error("Source byline for translation not found");
+			translationGroup = source.translationGroup ?? source.id;
+		}
+		let touchedGroupShared = false;
+		await withTransaction(this.db, async (trx) => {
+			await trx.insertInto("_dineway_bylines").values({
+				id,
+				slug: input.slug,
+				display_name: input.displayName,
+				bio: input.bio ?? null,
+				avatar_media_id: input.avatarMediaId ?? null,
+				website_url: input.websiteUrl ?? null,
+				user_id: input.userId ?? null,
+				is_guest: input.isGuest ? 1 : 0,
+				created_at: now,
+				updated_at: now,
+				...input.locale !== void 0 ? { locale: input.locale } : {},
+				translation_group: translationGroup
+			}).execute();
+			touchedGroupShared = await this.writeCustomFields(trx, id, translationGroup, customFieldWrites, now);
+		});
+		if (touchedGroupShared) clearRequestCacheEntry(`byline-field-group-values:${translationGroup}`);
+		const byline = await this.findById(id);
+		if (!byline) throw new Error("Failed to create byline");
+		return byline;
+	}
+	async update(id, input) {
+		const existing = await this.findById(id);
+		if (!existing) return null;
+		const customFieldWrites = await this.resolveCustomFieldWrites(input.customFields);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const updates = { updated_at: now };
+		if (input.slug !== void 0) updates.slug = input.slug;
+		if (input.displayName !== void 0) updates.display_name = input.displayName;
+		if (input.bio !== void 0) updates.bio = input.bio;
+		if (input.avatarMediaId !== void 0) updates.avatar_media_id = input.avatarMediaId;
+		if (input.websiteUrl !== void 0) updates.website_url = input.websiteUrl;
+		if (input.userId !== void 0) updates.user_id = input.userId;
+		if (input.isGuest !== void 0) updates.is_guest = input.isGuest ? 1 : 0;
+		const group = existing.translationGroup ?? existing.id;
+		let touchedGroupShared = false;
+		await withTransaction(this.db, async (trx) => {
+			await trx.updateTable("_dineway_bylines").set(updates).where("id", "=", id).execute();
+			touchedGroupShared = await this.writeCustomFields(trx, id, group, customFieldWrites, now);
+		});
+		if (touchedGroupShared) clearRequestCacheEntry(`byline-field-group-values:${group}`);
+		return await this.findById(id);
+	}
+	async delete(id) {
+		const existing = await this.findById(id);
+		if (!existing) return false;
+		const group = existing.translationGroup ?? existing.id;
+		await withTransaction(this.db, async (trx) => {
+			await trx.deleteFrom("_dineway_byline_field_values").where("byline_id", "=", id).execute();
+			await trx.deleteFrom("_dineway_bylines").where("id", "=", id).execute();
+			const remaining = await trx.selectFrom("_dineway_bylines").select(({ fn }) => [fn.count("id").as("count")]).where("translation_group", "=", group).executeTakeFirst();
+			if (Number(remaining?.count ?? 0) > 0) return;
+			await trx.deleteFrom("_dineway_content_bylines").where("byline_id", "=", group).execute();
+			await trx.deleteFrom("_dineway_byline_field_group_values").where("translation_group", "=", group).execute();
+			const tableNames = await listTablesLike(trx, "ec_%");
+			for (const tableName of tableNames) {
+				validateIdentifier(tableName, "content table");
+				await sql`
+					UPDATE ${sql.ref(tableName)}
+					SET primary_byline_id = NULL
+					WHERE primary_byline_id = ${group}
+				`.execute(trx);
+			}
+		});
+		clearRequestCacheEntry(`byline-field-group-values:${group}`);
+		return true;
+	}
+	async getContentBylines(collectionSlug, contentId, options) {
+		let query = this.db.selectFrom("_dineway_content_bylines as cb").innerJoin("_dineway_bylines as b", "b.translation_group", "cb.byline_id").leftJoin("media as m", "m.id", "b.avatar_media_id").select([
+			"cb.sort_order as sort_order",
+			"cb.role_label as role_label",
+			"b.id as id",
+			"b.slug as slug",
+			"b.display_name as display_name",
+			"b.bio as bio",
+			"b.avatar_media_id as avatar_media_id",
+			"m.storage_key as avatar_storage_key",
+			"m.alt as avatar_alt",
+			"b.website_url as website_url",
+			"b.user_id as user_id",
+			"b.is_guest as is_guest",
+			"b.created_at as created_at",
+			"b.updated_at as updated_at",
+			"b.locale as locale",
+			"b.translation_group as translation_group"
+		]).where("cb.collection_slug", "=", collectionSlug).where("cb.content_id", "=", contentId).orderBy("cb.sort_order", "asc");
+		if (options?.locale !== void 0) query = query.where("b.locale", "=", options.locale);
+		const rows = await query.execute();
+		const bylines = await this.withCustomFields(rows);
+		return rows.map((row, index) => ({
+			byline: bylines[index] ?? rowToByline(row),
+			sortOrder: row.sort_order,
+			roleLabel: row.role_label
+		}));
+	}
+	async hasContentBylines(collectionSlug, contentId) {
+		return await this.db.selectFrom("_dineway_content_bylines").select("id").where("collection_slug", "=", collectionSlug).where("content_id", "=", contentId).limit(1).executeTakeFirst() !== void 0;
+	}
+	async hasContentBylinesMany(collectionSlug, contentIds) {
+		const result = /* @__PURE__ */ new Set();
+		if (contentIds.length === 0) return result;
+		const uniqueContentIds = [...new Set(contentIds)];
+		for (const chunk of chunks(uniqueContentIds, SQL_BATCH_SIZE)) {
+			const rows = await this.db.selectFrom("_dineway_content_bylines").select("content_id").distinct().where("collection_slug", "=", collectionSlug).where("content_id", "in", chunk).execute();
+			for (const row of rows) result.add(row.content_id);
+		}
+		return result;
+	}
+	/**
+	* Batch-fetch byline credits for multiple content items in a single query.
+	* Returns a Map keyed by contentId.
+	*/
+	async getContentBylinesMany(collectionSlug, contentIds, options) {
+		const result = /* @__PURE__ */ new Map();
+		if (contentIds.length === 0) return result;
+		const uniqueContentIds = [...new Set(contentIds)];
+		for (const chunk of chunks(uniqueContentIds, SQL_BATCH_SIZE)) {
+			let query = this.db.selectFrom("_dineway_content_bylines as cb").innerJoin("_dineway_bylines as b", "b.translation_group", "cb.byline_id").leftJoin("media as m", "m.id", "b.avatar_media_id").select([
+				"cb.content_id as content_id",
+				"cb.sort_order as sort_order",
+				"cb.role_label as role_label",
+				"b.id as id",
+				"b.slug as slug",
+				"b.display_name as display_name",
+				"b.bio as bio",
+				"b.avatar_media_id as avatar_media_id",
+				"m.storage_key as avatar_storage_key",
+				"m.alt as avatar_alt",
+				"b.website_url as website_url",
+				"b.user_id as user_id",
+				"b.is_guest as is_guest",
+				"b.created_at as created_at",
+				"b.updated_at as updated_at",
+				"b.locale as locale",
+				"b.translation_group as translation_group"
+			]).where("cb.collection_slug", "=", collectionSlug).where("cb.content_id", "in", chunk).orderBy("cb.sort_order", "asc");
+			if (options?.locale !== void 0) query = query.where("b.locale", "=", options.locale);
+			const rows = await query.execute();
+			const bylines = options?.skipHydration ? rows.map(rowToByline) : await this.withCustomFields(rows);
+			for (let index = 0; index < rows.length; index++) {
+				const row = rows[index];
+				if (!row) continue;
+				const contentId = row.content_id;
+				const credit = {
+					byline: bylines[index] ?? rowToByline(row),
+					sortOrder: row.sort_order,
+					roleLabel: row.role_label
+				};
+				const existing = result.get(contentId);
+				if (existing) existing.push(credit);
+				else result.set(contentId, [credit]);
+			}
+		}
+		return result;
+	}
+	/**
+	* Batch-fetch byline profiles linked to user IDs in a single query.
+	* Returns a Map keyed by userId.
+	*/
+	async findByUserIds(userIds, options) {
+		const result = /* @__PURE__ */ new Map();
+		if (userIds.length === 0) return result;
+		for (const chunk of chunks(userIds, SQL_BATCH_SIZE)) {
+			let query = this.db.selectFrom("_dineway_bylines as b").leftJoin("media as m", "m.id", "b.avatar_media_id").select([
+				"b.id as id",
+				"b.slug as slug",
+				"b.display_name as display_name",
+				"b.bio as bio",
+				"b.avatar_media_id as avatar_media_id",
+				"m.storage_key as avatar_storage_key",
+				"m.alt as avatar_alt",
+				"b.website_url as website_url",
+				"b.user_id as user_id",
+				"b.is_guest as is_guest",
+				"b.created_at as created_at",
+				"b.updated_at as updated_at",
+				"b.locale as locale",
+				"b.translation_group as translation_group"
+			]).where("b.user_id", "in", chunk);
+			if (options?.locale !== void 0) query = query.where("b.locale", "=", options.locale);
+			const rows = await query.orderBy("b.locale", "asc").execute();
+			const bylines = options?.skipHydration ? rows.map(rowToByline) : await this.withCustomFields(rows);
+			for (let index = 0; index < rows.length; index++) {
+				const row = rows[index];
+				if (!row) continue;
+				if (row.user_id) result.set(row.user_id, bylines[index] ?? rowToByline(row));
+			}
+		}
+		return result;
+	}
+	async copyContentBylines(collectionSlug, sourceContentId, targetContentId) {
+		validateIdentifier(collectionSlug, "collection slug");
+		const tableName = `ec_${collectionSlug}`;
+		validateIdentifier(tableName, "content table");
+		if (await this.db.selectFrom("_dineway_content_bylines").select("id").where("collection_slug", "=", collectionSlug).where("content_id", "=", targetContentId).executeTakeFirst()) return;
+		const sourceRows = await this.db.selectFrom("_dineway_content_bylines").select([
+			"byline_id",
+			"sort_order",
+			"role_label"
+		]).where("collection_slug", "=", collectionSlug).where("content_id", "=", sourceContentId).orderBy("sort_order", "asc").execute();
+		if (sourceRows.length === 0) return;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		await this.db.insertInto("_dineway_content_bylines").values(sourceRows.map((row) => ({
+			id: ulid(),
+			collection_slug: collectionSlug,
+			content_id: targetContentId,
+			byline_id: row.byline_id,
+			sort_order: row.sort_order,
+			role_label: row.role_label,
+			created_at: now
+		}))).execute();
+		await sql`
+			UPDATE ${sql.ref(tableName)}
+			SET primary_byline_id = ${sourceRows[0]?.byline_id ?? null}
+			WHERE id = ${targetContentId}
+		`.execute(this.db);
+	}
+	async setContentBylines(collectionSlug, contentId, inputBylines) {
+		validateIdentifier(collectionSlug, "collection slug");
+		const tableName = `ec_${collectionSlug}`;
+		validateIdentifier(tableName, "content table");
+		const idToGroup = /* @__PURE__ */ new Map();
+		if (inputBylines.length > 0) {
+			const ids = [...new Set(inputBylines.map((item) => item.bylineId))];
+			const rows = await this.db.selectFrom("_dineway_bylines").select(["id", "translation_group"]).where("id", "in", ids).execute();
+			if (rows.length !== ids.length) throw new Error("One or more byline IDs do not exist");
+			for (const row of rows) idToGroup.set(row.id, row.translation_group ?? row.id);
+		}
+		const seenGroups = /* @__PURE__ */ new Set();
+		const bylines = [];
+		for (const item of inputBylines) {
+			const group = idToGroup.get(item.bylineId);
+			if (!group) throw new Error(`Missing translation group for byline ${item.bylineId}`);
+			if (seenGroups.has(group)) continue;
+			seenGroups.add(group);
+			bylines.push({
+				...item,
+				group
+			});
+		}
+		await this.db.deleteFrom("_dineway_content_bylines").where("collection_slug", "=", collectionSlug).where("content_id", "=", contentId).execute();
+		for (let i = 0; i < bylines.length; i++) {
+			const item = bylines[i];
+			if (!item) continue;
+			await this.db.insertInto("_dineway_content_bylines").values({
+				id: ulid(),
+				collection_slug: collectionSlug,
+				content_id: contentId,
+				byline_id: item.group,
+				sort_order: i,
+				role_label: item.roleLabel ?? null,
+				created_at: (/* @__PURE__ */ new Date()).toISOString()
+			}).execute();
+		}
+		await sql`
+			UPDATE ${sql.ref(tableName)}
+			SET primary_byline_id = ${bylines[0]?.group ?? null}
+			WHERE id = ${contentId}
+		`.execute(this.db);
+		return await this.getContentBylines(collectionSlug, contentId);
+	}
+};
+
+//#endregion
+export { BylineRepository as t };