@growth-labs/cms 0.8.2 → 0.8.4

package/src/engine/fronts-publish-intent.ts

@@ -304,15 +304,53 @@ export function parseFrontsChannelTargets(
 	return normalizeChannelTargets(parsed)
 }
 
+/** Host defaults are opt-in; an invalid configured list must fail before a save. */
+export function parseFrontsDefaultChannelTargets(
+	value: unknown,
+):
+	| { targets: string[] }
+	| { error: 'missing_fronts_default_channel_targets' | 'invalid_fronts_default_channel_targets' } {
+	if (value === undefined) return { error: 'missing_fronts_default_channel_targets' }
+	if (!Array.isArray(value)) return { error: 'invalid_fronts_default_channel_targets' }
+	const parsed = normalizeChannelTargets(value)
+	return 'code' in parsed ? { error: 'invalid_fronts_default_channel_targets' } : parsed
+}
+
+interface ScheduledTargetsSnapshot {
+	id: string
+	canonical_version: number | null
+	publish_at: number
+	updated_at: number | null
+	fronts_publish_trigger_token: string | null
+	fronts_publish_status: string | null
+}
+
+interface ChannelTargetsWriteOptions {
+	onlyIfNull?: boolean
+	expectedScheduled?: ScheduledTargetsSnapshot
+}
+
 /**
  * Arm an item's publish targets. Rejects an empty or non-string list loudly
  * instead of storing something that would later hydrate as "complete".
  */
+export function setFrontsChannelTargets(
+	db: D1Database,
+	contentId: string,
+	targets: readonly string[],
+): Promise<void>
+export function setFrontsChannelTargets(
+	db: D1Database,
+	contentId: string,
+	targets: readonly string[],
+	options: ChannelTargetsWriteOptions,
+): Promise<boolean>
 export async function setFrontsChannelTargets(
 	db: D1Database,
 	contentId: string,
 	targets: readonly string[],
-): Promise<void> {
+	options?: ChannelTargetsWriteOptions,
+): Promise<void | boolean> {
 	const normalized = normalizeChannelTargets(targets)
 	if ('code' in normalized) {
 		throw new FrontsPublishIntentError(
@@ -321,10 +359,83 @@ export async function setFrontsChannelTargets(
 			'targets must be a non-empty list of non-empty strings',
 		)
 	}
-	await db
-		.prepare('UPDATE content_items SET fronts_channel_targets = ? WHERE id = ?')
-		.bind(JSON.stringify(normalized.targets), contentId)
+	const predicates = ['id = ?']
+	const values: unknown[] = [JSON.stringify(normalized.targets), contentId]
+	if (options?.onlyIfNull || options?.expectedScheduled) {
+		predicates.push('fronts_channel_targets IS NULL', 'deleted_at IS NULL')
+	}
+	if (options?.expectedScheduled) {
+		const expected = options.expectedScheduled
+		if (expected.id !== contentId)
+			throw new Error('Channel target snapshot belongs to different content')
+		predicates.push(
+			"status = 'scheduled'",
+			'canonical_version IS ?',
+			'publish_at IS ?',
+			'updated_at IS ?',
+			'fronts_publish_trigger_token IS ?',
+			'fronts_publish_status IS ?',
+		)
+		values.push(
+			expected.canonical_version,
+			expected.publish_at,
+			expected.updated_at,
+			expected.fronts_publish_trigger_token,
+			expected.fronts_publish_status,
+		)
+	}
+	const result = await db
+		.prepare(
+			`UPDATE content_items SET fronts_channel_targets = ? WHERE ${predicates.join(' AND ')}`,
+		)
+		.bind(...values)
 		.run()
+	// Preserve the original explicit setter contract. CAS callers need a proved
+	// change count, including an honest false when another writer won.
+	if (!options) return
+	const changes = result.meta?.changes
+	if (
+		result.success === false ||
+		typeof changes !== 'number' ||
+		!Number.isInteger(changes) ||
+		changes < 0 ||
+		changes > 1
+	) {
+		throw new Error('Fronts channel target write did not report a valid change count')
+	}
+	return changes === 1
+}
+
+/** A bounded repair requested by Go; all rows keep their current publish/media identity. */
+export async function backfillFrontsChannelTargets(
+	db: D1Database,
+	targets: readonly string[],
+	limit: number,
+): Promise<{ examined: number; armed: number; skipped: number; contentIds: string[] }> {
+	if (!Number.isInteger(limit) || limit < 1 || limit > 50)
+		throw new Error('Invalid channel target backfill limit')
+	const selected = await db
+		.prepare(`SELECT id, canonical_version, publish_at, updated_at,
+			fronts_publish_trigger_token, fronts_publish_status
+			FROM content_items
+			WHERE status = 'scheduled' AND deleted_at IS NULL
+				AND publish_at IS NOT NULL AND fronts_channel_targets IS NULL
+			ORDER BY publish_at ASC, id ASC LIMIT ?`)
+		.bind(limit)
+		.all<ScheduledTargetsSnapshot>()
+	if (selected.success === false || !Array.isArray(selected.results))
+		throw new Error('Fronts channel target selection failed')
+	const contentIds: string[] = []
+	for (const row of selected.results) {
+		if (await setFrontsChannelTargets(db, row.id, targets, { expectedScheduled: row }))
+			contentIds.push(row.id)
+	}
+	return {
+		examined: selected.results.length,
+		armed: contentIds.length,
+		skipped: selected.results.length - contentIds.length,
+		contentIds,
+	}
 }
 
 // --- hydration -------------------------------------------------------------
@@ -427,6 +538,7 @@ interface VideoRefRow {
 	processing_source_url: string | null
 	processing_source_kind: string | null
 	processing_trigger_token: string | null
+	processing_state: string | null
 	processing_correlation_id: string | null
 }
 
@@ -438,6 +550,7 @@ interface PodcastRefRow {
 	processing_source_url: string | null
 	processing_source_kind: string | null
 	processing_trigger_token: string | null
+	processing_state: string | null
 }
 
 interface MediaRow {
@@ -571,7 +684,7 @@ async function loadContentRefSources(
 			.prepare(
 				`SELECT content_id, hls_ready, hls_manifest_url, hls_poster_url, duration_seconds,
 				        thumbnail_image_id, processing_source_url, processing_source_kind,
-				        processing_trigger_token, processing_correlation_id
+				        processing_trigger_token, processing_correlation_id, processing_state
 				 FROM video_content WHERE content_id IN (${placeholders(videoIds.length)})`,
 			)
 			.bind(...videoIds)
@@ -583,7 +696,7 @@ async function loadContentRefSources(
 	if (podcastIds.length > 0) {
 		const res = await db
 			.prepare(
-				`SELECT content_id, transcript, audio_r2_key, duration_seconds, processing_source_url, processing_source_kind, processing_trigger_token FROM podcast_content
+				`SELECT content_id, transcript, audio_r2_key, duration_seconds, processing_source_url, processing_source_kind, processing_trigger_token, processing_state FROM podcast_content
 				 WHERE content_id IN (${placeholders(podcastIds.length)})`,
 			)
 			.bind(...podcastIds)
@@ -617,6 +730,178 @@ async function loadContentRefSources(
 	return { articles, videos, podcasts, media }
 }
 
+/** Preparation and publication projections share the same source validation. */
+async function videoSourceRef(
+	row: IntentCandidateRow,
+	found: VideoRefRow | undefined,
+): Promise<FrontsPublishVideoSourceRef | null> {
+	const correlation = found?.processing_correlation_id?.trim()
+	if (
+		!found ||
+		!validPodcastSourceUrl(found.processing_source_url) ||
+		!videoSourceIngestableOverHttps(found.processing_source_kind) ||
+		!correlation ||
+		!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(correlation)
+	)
+		return null
+	if (
+		typeof found.duration_seconds !== 'number' ||
+		!Number.isFinite(found.duration_seconds) ||
+		found.duration_seconds <= 0
+	) {
+		throw new FrontsPublishIntentError(
+			'video_source_duration_unavailable',
+			row.id,
+			'Video source duration is not verified.',
+		)
+	}
+	if (found.processing_state !== 'queued' || !found.processing_trigger_token?.trim()) return null
+	return {
+		kind: 'https',
+		url: found.processing_source_url,
+		duration_seconds: found.duration_seconds,
+		generation: await frontsVideoSourceGeneration({
+			content_id: row.id,
+			slug: row.slug,
+			canonical_version: row.canonical_version as number,
+			processing_source_url: found.processing_source_url,
+			processing_source_kind: found.processing_source_kind,
+			processing_trigger_token: found.processing_trigger_token,
+		}),
+		correlation_id: correlation,
+		visibility: row.visibility === 'premium' ? 'premium' : 'free',
+	}
+}
+
+async function podcastSourceRef(
+	row: IntentCandidateRow,
+	found: PodcastRefRow | undefined,
+): Promise<FrontsPublishPodcastSourceRef | null> {
+	if (
+		!found ||
+		!validPodcastSourceUrl(found.processing_source_url) ||
+		found.processing_source_kind !== 'https'
+	)
+		return null
+	if (
+		typeof found.duration_seconds !== 'number' ||
+		!Number.isFinite(found.duration_seconds) ||
+		found.duration_seconds <= 0
+	) {
+		throw new FrontsPublishIntentError(
+			'podcast_source_duration_unavailable',
+			row.id,
+			'Podcast source duration is not verified.',
+		)
+	}
+	if (found.processing_state !== 'queued' || !found.processing_trigger_token?.trim()) return null
+	return {
+		kind: 'https',
+		url: found.processing_source_url,
+		duration_seconds: found.duration_seconds,
+		generation: await frontsPodcastSourceGeneration({
+			content_id: row.id,
+			slug: row.slug,
+			canonical_version: row.canonical_version as number,
+			processing_source_url: found.processing_source_url,
+			processing_source_kind: found.processing_source_kind,
+			processing_trigger_token: found.processing_trigger_token,
+		}),
+	}
+}
+
+/** A captured source is preparation authority, never publication authority. */
+export interface FrontsMediaPreparation {
+	content_id: string
+	type: 'video' | 'podcast'
+	slug: string
+	channel: string | null
+	canonical_version: number
+	/** The actual slot, if any; never invented for a draft. */
+	publish_at: number | null
+	/** Actual capture time; unknown for a legacy token. */
+	captured_at: number | null
+	video_source: FrontsPublishVideoSourceRef | null
+	podcast_source: FrontsPublishPodcastSourceRef | null
+}
+
+export interface FrontsMediaPreparations {
+	version: 1
+	items: FrontsMediaPreparation[]
+	incomplete: Array<{ content_id: string; code: string; message: string }>
+}
+
+/**
+ * Extend the existing authenticated poll with captured media, independently of
+ * publish_at/status=scheduled. No publish token, fake deadline or new queue is
+ * minted by this read. A finite complete response fails loudly on overflow.
+ */
+export async function hydrateFrontsMediaPreparations(
+	db: D1Database,
+	options: Pick<
+		HydrateFrontsPublishIntentsOptions,
+		'limit' | 'videoSourceProductionEnabled' | 'podcastSourceProductionEnabled'
+	> = {},
+): Promise<FrontsMediaPreparations> {
+	const limit = Math.min(Math.max(1, Math.floor(options.limit ?? 200)), 1000)
+	const result: FrontsMediaPreparations = { version: 1, items: [], incomplete: [] }
+	const candidates = await db
+		.prepare(`SELECT ${CANDIDATE_COLUMNS} FROM content_items
+		WHERE deleted_at IS NULL AND status IN ('draft', 'review', 'scheduled', 'published')
+		AND ((type = 'video' AND ? = 1 AND EXISTS (
+			SELECT 1 FROM video_content v WHERE v.content_id = content_items.id
+			AND v.processing_trigger_token IS NOT NULL AND v.processing_state = 'queued'
+			AND (v.hls_ready <> 1 OR v.hls_manifest_url IS NULL OR v.transcript_ready <> 1)))
+		OR (type = 'podcast' AND ? = 1 AND EXISTS (
+			SELECT 1 FROM podcast_content p WHERE p.content_id = content_items.id
+			AND p.processing_trigger_token IS NOT NULL AND p.processing_state = 'queued'
+			AND (trim(COALESCE(p.audio_r2_key, '')) = '' OR trim(COALESCE(p.transcript, '')) = ''))))
+		ORDER BY created_at ASC, id ASC LIMIT ?`)
+		.bind(
+			options.videoSourceProductionEnabled === false ? 0 : 1,
+			options.podcastSourceProductionEnabled === false ? 0 : 1,
+			limit + 1,
+		)
+		.all<IntentCandidateRow>()
+	const rows = candidates.results ?? []
+	if (rows.length > limit) throw new FrontsScheduleOverflowError(limit)
+	const refs = await loadContentRefSources(db, rows)
+	for (const row of rows) {
+		try {
+			if (!Number.isInteger(row.canonical_version) || (row.canonical_version ?? 0) <= 0) {
+				throw new FrontsPublishIntentError('invalid_canonical_version', row.id)
+			}
+			const video = row.type === 'video' ? await videoSourceRef(row, refs.videos.get(row.id)) : null
+			const podcast =
+				row.type === 'podcast' ? await podcastSourceRef(row, refs.podcasts.get(row.id)) : null
+			if (!video && !podcast)
+				throw new FrontsPublishIntentError(
+					row.type === 'video' ? 'video_media_not_ready' : 'missing_podcast_audio',
+					row.id,
+					'Captured source is incomplete or not ingestable.',
+				)
+			const token = (row.type === 'video' ? refs.videos.get(row.id) : refs.podcasts.get(row.id))
+				?.processing_trigger_token
+			const capturedAt = /^fronts-source-v2:([1-9][0-9]*):[0-9a-f-]{36}$/.exec(token ?? '')?.[1]
+			result.items.push({
+				content_id: row.id,
+				type: row.type as 'video' | 'podcast',
+				slug: row.slug,
+				channel: row.channel,
+				canonical_version: row.canonical_version as number,
+				publish_at: row.publish_at,
+				captured_at: capturedAt ? Number(capturedAt) : null,
+				video_source: video,
+				podcast_source: podcast,
+			})
+		} catch (error) {
+			if (!(error instanceof FrontsPublishIntentError)) throw error
+			result.incomplete.push({ content_id: row.id, code: error.code, message: error.message })
+		}
+	}
+	return result
+}
+
 /** Build one intent, throwing FrontsPublishIntentError on any missing required value. */
 async function buildIntent(
 	row: IntentCandidateRow,
@@ -739,41 +1024,8 @@ async function buildContentRefs(
 				message:
 					'a video intent requires video_content.hls_ready = 1 and a non-empty hls_manifest_url',
 			}
-			const sourceUrl = found?.processing_source_url
-			const correlationId = found?.processing_correlation_id?.trim()
-			if (
-				found &&
-				validPodcastSourceUrl(sourceUrl) &&
-				videoSourceIngestableOverHttps(found.processing_source_kind) &&
-				correlationId &&
-				/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(correlationId)
-			) {
-				if (
-					typeof found.duration_seconds !== 'number' ||
-					!Number.isFinite(found.duration_seconds) ||
-					found.duration_seconds <= 0
-				) {
-					throw new FrontsPublishIntentError(
-						'video_source_duration_unavailable',
-						row.id,
-						'Video source duration is not verified.',
-					)
-				}
-				videoSource = {
-					kind: 'https',
-					url: sourceUrl,
-					duration_seconds: found.duration_seconds,
-					generation: await frontsVideoSourceGeneration({
-						content_id: row.id,
-						slug: row.slug,
-						canonical_version: row.canonical_version as number,
-						processing_source_url: found.processing_source_url,
-						processing_source_kind: found.processing_source_kind,
-						processing_trigger_token: found.processing_trigger_token,
-					}),
-					correlation_id: correlationId,
-					visibility: row.visibility === 'premium' ? 'premium' : 'free',
-				}
+			videoSource = await videoSourceRef(row, found)
+			if (videoSource) {
 				incomplete = {
 					content_id: row.id,
 					code: failure.code,
@@ -824,32 +1076,8 @@ async function buildContentRefs(
 				code: 'missing_podcast_audio' as const,
 				message: 'Podcast audio is not ready.',
 			}
-			const sourceUrl = found?.processing_source_url
-			if (found && validPodcastSourceUrl(sourceUrl) && found.processing_source_kind === 'https') {
-				if (
-					typeof found.duration_seconds !== 'number' ||
-					!Number.isFinite(found.duration_seconds) ||
-					found.duration_seconds <= 0
-				) {
-					throw new FrontsPublishIntentError(
-						'podcast_source_duration_unavailable',
-						row.id,
-						'Podcast source duration is not verified.',
-					)
-				}
-				podcastSource = {
-					kind: 'https',
-					url: sourceUrl,
-					duration_seconds: found.duration_seconds,
-					generation: await frontsPodcastSourceGeneration({
-						content_id: row.id,
-						slug: row.slug,
-						canonical_version: row.canonical_version as number,
-						processing_source_url: found.processing_source_url,
-						processing_source_kind: found.processing_source_kind,
-						processing_trigger_token: found.processing_trigger_token,
-					}),
-				}
+			podcastSource = await podcastSourceRef(row, found)
+			if (podcastSource) {
 				incomplete = {
 					content_id: row.id,
 					code: failure.code,