emdash 0.35.0 → 0.36.0

package/src/media/usage/activation.ts

@@ -12,6 +12,20 @@ const ACTIVATION_KEY = "incremental_capture";
 const ACTIVATION_ERROR_CODE = "MEDIA_USAGE_ACTIVATION_FAILED";
 export const MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION = 1;
 
+export class MediaUsageActivationVersionMismatchError extends Error {}
+
+export interface MediaUsageActivationStatus {
+	state: "expanded" | "activating" | "active";
+	collectionCursor: string | null;
+	attemptCount: number;
+	drainConfirmedAt: string | null;
+	lastAttemptedAt: string | null;
+	lastErrorCode: "MEDIA_USAGE_ACTIVATION_FAILED" | null;
+	leaseExpiresAt: string | null;
+	activatedAt: string | null;
+	updatedAt: string;
+}
+
 export const MEDIA_USAGE_ACTIVATION_LIMITS = Object.freeze({
 	collectionsPerCall: 1,
 	leaseDurationSeconds: 5 * 60,
@@ -27,6 +41,12 @@ export type MediaUsageActivationResult =
 	| { outcome: "lease_active"; leaseExpiresAt: string }
 	| { outcome: "conflict"; processedCollections: number };
 
+export type MediaUsageActivationContinuationResult =
+	| MediaUsageActivationResult
+	| { outcome: "inactive" | "failed" };
+
+type MediaUsageActivationClaimMode = "confirmed" | "background";
+
 export interface MediaUsageCollectionCapturePreparation {
 	captureRequired: boolean;
 	collectionId: string;
@@ -34,6 +54,50 @@ export interface MediaUsageCollectionCapturePreparation {
 	resuming: boolean;
 }
 
+export async function getMediaUsageActivationStatus(
+	db: Kysely<Database>,
+): Promise<MediaUsageActivationStatus> {
+	const activation = await db
+		.selectFrom("_emdash_media_usage_activation")
+		.select([
+			"state",
+			"runtime_generation",
+			"collection_cursor",
+			"drain_confirmed_at",
+			"lease_expires_at",
+			"attempt_count",
+			"last_attempted_at",
+			"last_error_code",
+			"activated_at",
+			"updated_at",
+		])
+		.where("task_key", "=", ACTIVATION_KEY)
+		.executeTakeFirstOrThrow();
+	assertRuntimeGeneration(activation);
+	if (
+		activation.state !== "expanded" &&
+		activation.state !== "activating" &&
+		activation.state !== "active"
+	) {
+		throw new Error("Invalid media usage activation state");
+	}
+	if (!Number.isInteger(activation.attempt_count) || activation.attempt_count < 0) {
+		throw new Error("Invalid media usage activation attempt count");
+	}
+
+	return {
+		state: activation.state,
+		collectionCursor: activation.collection_cursor,
+		attemptCount: activation.attempt_count,
+		drainConfirmedAt: activation.drain_confirmed_at,
+		lastAttemptedAt: activation.last_attempted_at,
+		lastErrorCode: activation.last_error_code === null ? null : ACTIVATION_ERROR_CODE,
+		leaseExpiresAt: activation.lease_expires_at,
+		activatedAt: activation.activated_at,
+		updatedAt: activation.updated_at,
+	};
+}
+
 export async function canResumeMediaUsageCollectionCapture(
 	db: Kysely<Database>,
 	identity: { collectionId: string; collectionSlug: string; creationFingerprint?: string },
@@ -216,16 +280,45 @@ export async function activateMediaUsageCapture(
 	if (input.writersDrained !== true) {
 		throw new Error("Media usage activation requires confirmation that writers are drained");
 	}
+	return advanceMediaUsageActivation(db, "confirmed");
+}
+
+export async function continueMediaUsageActivation(
+	db: Kysely<Database>,
+): Promise<MediaUsageActivationContinuationResult> {
+	return advanceMediaUsageActivation(db, "background");
+}
 
+async function advanceMediaUsageActivation(
+	db: Kysely<Database>,
+	mode: "confirmed",
+): Promise<MediaUsageActivationResult>;
+async function advanceMediaUsageActivation(
+	db: Kysely<Database>,
+	mode: "background",
+): Promise<MediaUsageActivationContinuationResult>;
+async function advanceMediaUsageActivation(
+	db: Kysely<Database>,
+	mode: MediaUsageActivationClaimMode,
+): Promise<MediaUsageActivationContinuationResult> {
 	const before = await findActivation(db);
 	assertRuntimeGeneration(before);
 	if (before.state === "active") {
 		return { outcome: "active", processedCollections: 0 };
 	}
+	if (mode === "background") {
+		if (before.state === "expanded" || before.drain_confirmed_at === null) {
+			return { outcome: "inactive" };
+		}
+		if (before.state !== "activating") {
+			throw new Error("Invalid media usage activation state");
+		}
+		if (before.last_error_code !== null) return { outcome: "failed" };
+	}
 
 	const leaseToken = ulid();
-	const lease = await claimActivation(db, leaseToken);
-	if (!lease) return activationClaimLoss(db);
+	const lease = await claimActivation(db, leaseToken, mode);
+	if (!lease) return activationClaimLoss(db, mode);
 
 	let processedCollections = 0;
 	try {
@@ -308,56 +401,87 @@ async function findActivationIfAvailable(
 	return findActivation(db);
 }
 
-function assertRuntimeGeneration(activation: Selectable<MediaUsageActivationTable>): void {
+function assertRuntimeGeneration(activation: { runtime_generation: number }): void {
 	if (activation.runtime_generation !== MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION) {
-		throw new Error("Media usage activation runtime generation mismatch");
+		throw new MediaUsageActivationVersionMismatchError(
+			"Media usage activation runtime generation mismatch",
+		);
 	}
 }
 
 async function claimActivation(
 	db: Kysely<Database>,
 	leaseToken: string,
+	mode: MediaUsageActivationClaimMode,
 ): Promise<Selectable<MediaUsageActivationTable> | null> {
 	const now = timestampOffset(db, 0);
-	return (
-		(await db
-			.updateTable("_emdash_media_usage_activation")
-			.set({
-				state: "activating",
-				drain_confirmed_at: now,
-				lease_token: leaseToken,
-				lease_expires_at: timestampOffset(db, MEDIA_USAGE_ACTIVATION_LIMITS.leaseDurationSeconds),
-				attempt_count: sql<number>`attempt_count + 1`,
-				last_attempted_at: now,
-				last_error_code: null,
-				updated_at: now,
-			})
-			.where("task_key", "=", ACTIVATION_KEY)
-			.where("runtime_generation", "=", MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION)
-			.where((eb) =>
-				eb.or([
-					eb("state", "=", "expanded"),
-					eb.and([
-						eb("state", "=", "activating"),
-						eb.or([
-							eb("lease_token", "is", null),
-							eb.and([
-								eb("lease_expires_at", "is not", null),
-								timestampIsDue(db, "lease_expires_at"),
-							]),
+	const claimValues = {
+		lease_token: leaseToken,
+		lease_expires_at: timestampOffset(db, MEDIA_USAGE_ACTIVATION_LIMITS.leaseDurationSeconds),
+		attempt_count: sql<number>`attempt_count + 1`,
+		last_attempted_at: now,
+		updated_at: now,
+	};
+	let claim = db
+		.updateTable("_emdash_media_usage_activation")
+		.set(
+			mode === "confirmed"
+				? {
+						...claimValues,
+						state: "activating",
+						drain_confirmed_at: now,
+						last_error_code: null,
+					}
+				: claimValues,
+		)
+		.where("task_key", "=", ACTIVATION_KEY)
+		.where("runtime_generation", "=", MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION);
+	if (mode === "confirmed") {
+		claim = claim.where((eb) =>
+			eb.or([
+				eb("state", "=", "expanded"),
+				eb.and([
+					eb("state", "=", "activating"),
+					eb.or([
+						eb("lease_token", "is", null),
+						eb.and([
+							eb("lease_expires_at", "is not", null),
+							timestampIsDue(db, "lease_expires_at"),
 						]),
 					]),
 				]),
-			)
-			.returningAll()
-			.executeTakeFirst()) ?? null
-	);
+			]),
+		);
+	} else {
+		claim = claim
+			.where("state", "=", "activating")
+			.where("drain_confirmed_at", "is not", null)
+			.where("last_error_code", "is", null)
+			.where((eb) =>
+				eb.or([
+					eb("lease_token", "is", null),
+					eb.and([eb("lease_expires_at", "is not", null), timestampIsDue(db, "lease_expires_at")]),
+				]),
+			);
+	}
+	return (await claim.returningAll().executeTakeFirst()) ?? null;
 }
 
-async function activationClaimLoss(db: Kysely<Database>): Promise<MediaUsageActivationResult> {
+async function activationClaimLoss(
+	db: Kysely<Database>,
+	mode: MediaUsageActivationClaimMode,
+): Promise<MediaUsageActivationContinuationResult> {
 	const current = await findActivation(db);
 	assertRuntimeGeneration(current);
 	if (current.state === "active") return { outcome: "active", processedCollections: 0 };
+	if (mode === "background") {
+		if (current.state === "expanded" || current.drain_confirmed_at === null) {
+			return { outcome: "inactive" };
+		}
+		if (current.state === "activating" && current.last_error_code !== null) {
+			return { outcome: "failed" };
+		}
+	}
 	if (
 		current.state === "activating" &&
 		current.lease_token &&
@@ -366,6 +490,9 @@ async function activationClaimLoss(db: Kysely<Database>): Promise<MediaUsageActi
 	) {
 		return { outcome: "lease_active", leaseExpiresAt: current.lease_expires_at };
 	}
+	if (mode === "background" && current.state === "activating") {
+		return { outcome: "conflict", processedCollections: 0 };
+	}
 	throw new Error("Media usage activation state is not claimable");
 }
 

package/src/media/usage/capture-triggers.ts

@@ -8,6 +8,7 @@ const POSTGRES_TRIGGER_FUNCTION = "emdash_media_usage_capture_work";
 const POSTGRES_IDENTIFIER_LIMIT = 63;
 const CAPTURE_TRIGGER_VERSION = 1;
 const OWNED_TRIGGER_PREFIX = "emdash_mu_";
+const MAX_OWNED_CAPTURE_TRIGGERS = 100;
 const WHITESPACE_PATTERN = /\s+/g;
 const TRAILING_SEMICOLON_PATTERN = /;$/;
 
@@ -25,7 +26,14 @@ export async function installMediaUsageCaptureTriggers(
 ): Promise<void> {
 	const identifiers = await captureIdentifiers(identity);
 	if (isPostgres(db)) await installPostgresFunction(db);
-	const installedNames = await listOwnedCaptureTriggers(db, identifiers.tableName);
+	const installedNames = await listOwnedCaptureTriggers(
+		db,
+		identifiers.tableName,
+		MAX_OWNED_CAPTURE_TRIGGERS + 1,
+	);
+	if (installedNames.length > MAX_OWNED_CAPTURE_TRIGGERS) {
+		throw new Error("Media usage capture trigger set exceeds the activation limit");
+	}
 	if (await hasExactCaptureTriggers(db, identifiers, identity, installedNames)) {
 		return;
 	}
@@ -77,7 +85,7 @@ export async function verifyMediaUsageCaptureTriggers(
 		db,
 		identifiers,
 		identity,
-		await listOwnedCaptureTriggers(db, identifiers.tableName),
+		await listOwnedCaptureTriggers(db, identifiers.tableName, MAX_OWNED_CAPTURE_TRIGGERS + 1),
 	);
 }
 
@@ -150,7 +158,9 @@ async function removeCaptureTriggers(
 async function listOwnedCaptureTriggers(
 	db: Kysely<Database>,
 	tableName: string,
+	limit?: number,
 ): Promise<string[]> {
+	const limitClause = limit === undefined ? sql`` : sql`LIMIT ${limit}`;
 	if (isPostgres(db)) {
 		const result = await sql<{ name: string }>`
 			SELECT trigger.tgname AS name
@@ -161,6 +171,7 @@ async function listOwnedCaptureTriggers(
 				AND relation.relname = ${tableName}
 				AND NOT trigger.tgisinternal
 				AND left(trigger.tgname, 10) = ${OWNED_TRIGGER_PREFIX}
+			${limitClause}
 		`.execute(db);
 		return result.rows.map((row) => row.name);
 	}
@@ -171,6 +182,7 @@ async function listOwnedCaptureTriggers(
 		WHERE type = 'trigger'
 			AND tbl_name = ${tableName}
 			AND substr(name, 1, 10) = ${OWNED_TRIGGER_PREFIX}
+		${limitClause}
 	`.execute(db);
 	return result.rows.map((row) => row.name);
 }
@@ -307,7 +319,11 @@ async function assertExpectedTriggerSet(
 	},
 	identity: MediaUsageCaptureIdentity,
 ): Promise<void> {
-	const actual = await listOwnedCaptureTriggers(db, identifiers.tableName);
+	const actual = await listOwnedCaptureTriggers(
+		db,
+		identifiers.tableName,
+		MAX_OWNED_CAPTURE_TRIGGERS + 1,
+	);
 	if (!(await hasExactCaptureTriggers(db, identifiers, identity, actual))) {
 		throw new Error("Media usage capture trigger installation is incomplete");
 	}

package/src/media/usage/collection-deletion-processor.ts

@@ -12,13 +12,11 @@ import {
 
 export const MEDIA_USAGE_COLLECTION_DELETION_LIMITS = Object.freeze({
 	candidatesPerTick: 4,
-	deletionsPerTick: 1,
 	rowsPerBatch: 50,
 	leaseDurationSeconds: 5 * 60,
 	maxAttempts: 5,
 	retryBaseSeconds: 30,
 	retryMaxSeconds: 15 * 60,
-	maxQueriesPerTick: 30,
 });
 
 export interface MediaUsageCollectionDeletionTickResult {
@@ -36,7 +34,13 @@ export async function processDueMediaUsageCollectionDeletions(
 	const candidates = await repository.findDue(
 		MEDIA_USAGE_COLLECTION_DELETION_LIMITS.candidatesPerTick,
 	);
-	if (candidates.length === 0) return { candidateCount: 0, claimedCount: 0, outcome: "idle" };
+	if (candidates.length === 0) {
+		return {
+			candidateCount: (await repository.hasNonterminal()) ? 1 : 0,
+			claimedCount: 0,
+			outcome: "idle",
+		};
+	}
 
 	let claim: (MediaUsageCollectionDeletionRecord & { leaseToken: string }) | null = null;
 	for (const candidate of candidates) {

package/src/media/usage/collection-deletion.ts

@@ -193,6 +193,16 @@ export class MediaUsageCollectionDeletionRepository {
 		return result.rows.map(rowToRecord);
 	}
 
+	async hasNonterminal(): Promise<boolean> {
+		const row = await this.db
+			.selectFrom("_emdash_media_usage_collection_deletions")
+			.select("collection_id")
+			.where("state", "in", ["pending", "retry", "leased"])
+			.limit(1)
+			.executeTakeFirst();
+		return row !== undefined;
+	}
+
 	async findOperatorPage(options: {
 		state?: MediaUsageCollectionDeletionState;
 		limit?: number;