emdash 0.32.0 → 0.34.0

package/src/database/migrations/063_media_usage_incremental_work.ts

@@ -0,0 +1,397 @@
+import { sql, type Kysely, type RawBuilder } from "kysely";
+
+import { columnExists, isPostgres, tableExists } from "../dialect-helpers.js";
+
+const ACTIVATION_KEY = "incremental_capture";
+const CONTENT_ADAPTER_ID = "content-media";
+const COLLECTION_SCOPE = "collection";
+const DUPLICATE_COLUMN_RE = /(?:duplicate column|column .* already exists|already exists.*column)/i;
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createTable("_emdash_media_usage_activation")
+		.ifNotExists()
+		.addColumn("task_key", "text", (column) => column.primaryKey())
+		.addColumn("state", "text", (column) => column.notNull().defaultTo("expanded"))
+		.addColumn("runtime_generation", "integer", (column) => column.notNull().defaultTo(1))
+		.addColumn("collection_cursor", "text")
+		.addColumn("drain_confirmed_at", "text")
+		.addColumn("lease_token", "text")
+		.addColumn("lease_expires_at", "text")
+		.addColumn("attempt_count", "integer", (column) => column.notNull().defaultTo(0))
+		.addColumn("last_attempted_at", "text")
+		.addColumn("last_error_code", "text")
+		.addColumn("activated_at", "text")
+		.addColumn("created_at", "text", (column) =>
+			column.notNull().defaultTo(sortableUtcTimestamp(db)),
+		)
+		.addColumn("updated_at", "text", (column) =>
+			column.notNull().defaultTo(sortableUtcTimestamp(db)),
+		)
+		.execute();
+
+	await sql`
+		INSERT INTO _emdash_media_usage_activation (task_key, state)
+		VALUES (${ACTIVATION_KEY}, 'expanded')
+		ON CONFLICT (task_key) DO NOTHING
+	`.execute(db);
+
+	await db.schema
+		.createTable("_emdash_media_usage_work")
+		.ifNotExists()
+		.addColumn("collection_id", "text", (column) => column.notNull())
+		.addColumn("collection_slug", "text", (column) => column.notNull())
+		.addColumn("content_id", "text", (column) => column.notNull())
+		.addColumn("change_epoch", "bigint", (column) => column.notNull())
+		.addColumn("work_version", "bigint", (column) => column.notNull().defaultTo(1))
+		.addColumn("state", "text", (column) => column.notNull().defaultTo("pending"))
+		.addColumn("attempt_count", "integer", (column) => column.notNull().defaultTo(0))
+		.addColumn("next_attempt_at", "text", (column) => column.notNull())
+		.addColumn("lease_token", "text")
+		.addColumn("lease_expires_at", "text")
+		.addColumn("last_attempted_at", "text")
+		.addColumn("last_error_code", "text")
+		.addColumn("created_at", "text", (column) =>
+			column.notNull().defaultTo(sortableUtcTimestamp(db)),
+		)
+		.addColumn("updated_at", "text", (column) =>
+			column.notNull().defaultTo(sortableUtcTimestamp(db)),
+		)
+		.addPrimaryKeyConstraint("_emdash_media_usage_work_pk", ["collection_id", "content_id"])
+		.execute();
+
+	await addStatusColumns(db);
+	await addSourceColumns(db);
+
+	await db.schema
+		.createIndex("idx__emdash_media_usage_work_due")
+		.ifNotExists()
+		.on("_emdash_media_usage_work")
+		.columns(["state", "next_attempt_at", "updated_at", "collection_id", "content_id"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_work_lease")
+		.ifNotExists()
+		.on("_emdash_media_usage_work")
+		.columns(["state", "lease_expires_at", "collection_id", "content_id"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_work_operator")
+		.ifNotExists()
+		.on("_emdash_media_usage_work")
+		.columns(["collection_id", "state", "updated_at", "content_id"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_status_collection")
+		.ifNotExists()
+		.unique()
+		.on("_emdash_media_usage_index_status")
+		.columns(["adapter_id", "scope_type", "collection_id"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_sources_identity")
+		.ifNotExists()
+		.on("_emdash_media_usage_sources")
+		.columns(["source_type", "collection_id", "content_id", "source_variant"])
+		.execute();
+
+	await sql`
+		DELETE FROM _emdash_media_usage_index_status
+		WHERE adapter_id = ${CONTENT_ADAPTER_ID}
+			AND scope_type = ${COLLECTION_SCOPE}
+			AND (
+				(
+					collection_id IS NULL
+					AND NOT EXISTS (
+						SELECT 1
+						FROM _emdash_collections AS collection
+						WHERE collection.slug = _emdash_media_usage_index_status.scope_key
+					)
+				)
+				OR (
+					collection_id IS NOT NULL
+					AND capture_state = 'installing'
+					AND EXISTS (
+						SELECT 1
+						FROM _emdash_media_usage_activation AS activation
+						WHERE activation.task_key = ${ACTIVATION_KEY}
+							AND activation.state = 'expanded'
+					)
+					AND NOT EXISTS (
+						SELECT 1
+						FROM _emdash_collections AS collection
+						WHERE collection.id = _emdash_media_usage_index_status.collection_id
+							AND collection.slug = _emdash_media_usage_index_status.scope_key
+					)
+				)
+			)
+	`.execute(db);
+
+	await sql`
+		UPDATE _emdash_media_usage_index_status
+		SET collection_id = (
+				SELECT collection.id
+				FROM _emdash_collections AS collection
+				WHERE collection.slug = _emdash_media_usage_index_status.scope_key
+			),
+			reconciliation_required = 1,
+			capture_state = COALESCE(capture_state, 'installing')
+		WHERE adapter_id = ${CONTENT_ADAPTER_ID}
+			AND scope_type = ${COLLECTION_SCOPE}
+			AND (
+				collection_id IS NULL
+				OR capture_state IS NULL
+			)
+			AND EXISTS (
+				SELECT 1
+				FROM _emdash_collections AS collection
+				WHERE collection.id = COALESCE(
+					_emdash_media_usage_index_status.collection_id,
+					collection.id
+				)
+					AND collection.slug = _emdash_media_usage_index_status.scope_key
+			)
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await assertRollbackIsEmptyAndInactive(db);
+
+	await db.schema.dropIndex("idx__emdash_media_usage_sources_identity").ifExists().execute();
+	await db.schema.dropIndex("idx__emdash_media_usage_status_collection").ifExists().execute();
+	await db.schema.dropIndex("idx__emdash_media_usage_work_operator").ifExists().execute();
+	await db.schema.dropIndex("idx__emdash_media_usage_work_lease").ifExists().execute();
+	await db.schema.dropIndex("idx__emdash_media_usage_work_due").ifExists().execute();
+	await db.schema.dropTable("_emdash_media_usage_work").ifExists().execute();
+	await db.schema.dropTable("_emdash_media_usage_activation").ifExists().execute();
+	if (isPostgres(db)) {
+		await sql`DROP FUNCTION IF EXISTS emdash_media_usage_capture_work()`.execute(db);
+	}
+
+	for (const columnName of ["identity_version", "collection_id"] as const) {
+		if (await columnExists(db, "_emdash_media_usage_sources", columnName)) {
+			await db.schema.alterTable("_emdash_media_usage_sources").dropColumn(columnName).execute();
+		}
+	}
+
+	for (const columnName of [
+		"capture_state",
+		"last_incremental_success_at",
+		"reconciliation_required",
+		"change_epoch",
+		"collection_id",
+	] as const) {
+		if (await columnExists(db, "_emdash_media_usage_index_status", columnName)) {
+			await db.schema
+				.alterTable("_emdash_media_usage_index_status")
+				.dropColumn(columnName)
+				.execute();
+		}
+	}
+}
+
+async function addStatusColumns(db: Kysely<unknown>): Promise<void> {
+	await addColumnIfMissing(db, "_emdash_media_usage_index_status", "collection_id", () =>
+		db.schema
+			.alterTable("_emdash_media_usage_index_status")
+			.addColumn("collection_id", "text")
+			.execute(),
+	);
+	await addColumnIfMissing(db, "_emdash_media_usage_index_status", "change_epoch", () =>
+		db.schema
+			.alterTable("_emdash_media_usage_index_status")
+			.addColumn("change_epoch", "bigint", (column) => column.notNull().defaultTo(0))
+			.execute(),
+	);
+	await addColumnIfMissing(db, "_emdash_media_usage_index_status", "reconciliation_required", () =>
+		db.schema
+			.alterTable("_emdash_media_usage_index_status")
+			.addColumn("reconciliation_required", "integer", (column) => column.notNull().defaultTo(0))
+			.execute(),
+	);
+	await addStatusTextColumn(db, "last_incremental_success_at");
+	await addStatusTextColumn(db, "capture_state");
+}
+
+async function assertRollbackIsEmptyAndInactive(db: Kysely<unknown>): Promise<void> {
+	if (await hasCaptureTriggers(db)) {
+		throw new Error("Cannot roll back media usage capture while capture triggers are installed");
+	}
+
+	if (await tableExists(db, "_emdash_media_usage_activation")) {
+		const activation = await sql<{ state: string }>`
+			SELECT state
+			FROM _emdash_media_usage_activation
+			WHERE task_key = ${ACTIVATION_KEY}
+		`.execute(db);
+		if (activation.rows[0] && activation.rows[0].state !== "expanded") {
+			throw new Error("Cannot roll back media usage capture after activation has started");
+		}
+	}
+
+	if (await tableExists(db, "_emdash_media_usage_work")) {
+		const work = await sql<{ present: number }>`
+			SELECT 1 AS present FROM _emdash_media_usage_work LIMIT 1
+		`.execute(db);
+		if (work.rows.length > 0) {
+			throw new Error("Cannot roll back media usage capture while durable work exists");
+		}
+	}
+
+	const sourceHasCollectionId = await columnExists(
+		db,
+		"_emdash_media_usage_sources",
+		"collection_id",
+	);
+	const sourceHasIdentityVersion = await columnExists(
+		db,
+		"_emdash_media_usage_sources",
+		"identity_version",
+	);
+	if (sourceHasCollectionId || sourceHasIdentityVersion) {
+		const canonicalSources = sourceHasCollectionId
+			? await sql<{ present: number }>`
+					SELECT 1 AS present
+					FROM _emdash_media_usage_sources
+					WHERE collection_id IS NOT NULL
+					LIMIT 1
+				`.execute(db)
+			: await sql<{ present: number }>`
+					SELECT 1 AS present
+					FROM _emdash_media_usage_sources
+					WHERE identity_version IS NOT NULL
+					LIMIT 1
+				`.execute(db);
+		if (canonicalSources.rows.length > 0) {
+			throw new Error("Cannot roll back media usage capture after canonical sources exist");
+		}
+		if (sourceHasCollectionId && sourceHasIdentityVersion) {
+			const versionedSources = await sql<{ present: number }>`
+				SELECT 1 AS present
+				FROM _emdash_media_usage_sources
+				WHERE identity_version IS NOT NULL
+				LIMIT 1
+			`.execute(db);
+			if (versionedSources.rows.length > 0) {
+				throw new Error("Cannot roll back media usage capture after canonical sources exist");
+			}
+		}
+	}
+
+	if (await columnExists(db, "_emdash_media_usage_index_status", "capture_state")) {
+		const lifecycle = await sql<{ present: number }>`
+			SELECT 1 AS present FROM _emdash_media_usage_index_status
+			WHERE capture_state IN ('active', 'deleting') LIMIT 1
+		`.execute(db);
+		if (lifecycle.rows.length > 0) throwRollbackLifecycleError();
+	}
+	if (await columnExists(db, "_emdash_media_usage_index_status", "change_epoch")) {
+		const epoch = await sql<{ present: number }>`
+			SELECT 1 AS present FROM _emdash_media_usage_index_status
+			WHERE change_epoch <> 0 LIMIT 1
+		`.execute(db);
+		if (epoch.rows.length > 0) throwRollbackLifecycleError();
+	}
+	if (await columnExists(db, "_emdash_media_usage_index_status", "last_incremental_success_at")) {
+		const success = await sql<{ present: number }>`
+			SELECT 1 AS present FROM _emdash_media_usage_index_status
+			WHERE last_incremental_success_at IS NOT NULL LIMIT 1
+		`.execute(db);
+		if (success.rows.length > 0) throwRollbackLifecycleError();
+	}
+}
+
+function throwRollbackLifecycleError(): never {
+	throw new Error("Cannot roll back media usage capture while capture lifecycle state exists");
+}
+
+async function hasCaptureTriggers(db: Kysely<unknown>): Promise<boolean> {
+	if (isPostgres(db)) {
+		const result = await sql<{ present: boolean }>`
+			SELECT EXISTS (
+				SELECT 1
+				FROM pg_trigger AS trigger
+				INNER JOIN pg_class AS relation ON relation.oid = trigger.tgrelid
+				INNER JOIN pg_namespace AS namespace ON namespace.oid = relation.relnamespace
+				WHERE namespace.nspname = current_schema()
+					AND NOT trigger.tgisinternal
+					AND left(trigger.tgname, 10) = 'emdash_mu_'
+			) AS present
+		`.execute(db);
+		return result.rows[0]?.present === true;
+	}
+
+	const result = await sql<{ present: number }>`
+		SELECT 1 AS present
+		FROM sqlite_master
+		WHERE type = 'trigger' AND substr(name, 1, 10) = 'emdash_mu_'
+		LIMIT 1
+	`.execute(db);
+	return result.rows.length > 0;
+}
+
+async function addStatusTextColumn(db: Kysely<unknown>, columnName: string): Promise<void> {
+	await addColumnIfMissing(db, "_emdash_media_usage_index_status", columnName, () =>
+		db.schema
+			.alterTable("_emdash_media_usage_index_status")
+			.addColumn(columnName, "text")
+			.execute(),
+	);
+}
+
+async function addSourceColumns(db: Kysely<unknown>): Promise<void> {
+	await addColumnIfMissing(db, "_emdash_media_usage_sources", "collection_id", () =>
+		db.schema
+			.alterTable("_emdash_media_usage_sources")
+			.addColumn("collection_id", "text")
+			.execute(),
+	);
+	await addColumnIfMissing(db, "_emdash_media_usage_sources", "identity_version", () =>
+		db.schema
+			.alterTable("_emdash_media_usage_sources")
+			.addColumn("identity_version", "integer")
+			.execute(),
+	);
+}
+
+async function addColumnIfMissing(
+	db: Kysely<unknown>,
+	tableName: string,
+	columnName: string,
+	addColumn: () => Promise<void>,
+): Promise<void> {
+	if (await columnExists(db, tableName, columnName)) return;
+
+	try {
+		await addColumn();
+	} catch (error) {
+		if (DUPLICATE_COLUMN_RE.test(deepErrorMessage(error))) {
+			if (await columnExists(db, tableName, columnName)) return;
+		}
+		throw error;
+	}
+}
+
+function sortableUtcTimestamp(db: Kysely<unknown>): RawBuilder<string> {
+	if (isPostgres(db)) {
+		return sql`to_char(clock_timestamp() AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`;
+	}
+	return sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`;
+}
+
+function deepErrorMessage(error: unknown): string {
+	if (error instanceof Error) {
+		const own = error.message ?? "";
+		if (error.cause) {
+			const causeMessage = deepErrorMessage(error.cause);
+			return own ? `${own}: ${causeMessage}` : causeMessage;
+		}
+		return own;
+	}
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}

package/src/database/migrations/064_fts_plain_text.ts

@@ -0,0 +1,253 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { isSqlite } from "../dialect-helpers.js";
+import { validateIdentifier } from "../validate.js";
+
+/**
+ * Migration: Rebuild FTS5 indexes as self-contained tables indexing
+ * extracted Portable Text prose
+ *
+ * Background: FTS tables were external-content (`content='ec_<slug>'`),
+ * which forces the index to mirror the raw column values — and Portable
+ * Text fields store JSON, so the index was polluted with structural tokens
+ * (`_type`, `span`, style values like `normal`, `_key` ULIDs). Searches for
+ * those tokens matched nearly every document and snippets showed JSON
+ * fragments.
+ *
+ * The fix rebuilds each search-enabled collection's FTS table as a
+ * self-contained FTS5 table (no `content=` option) whose Portable Text
+ * columns hold extracted prose — every JSON string under a `text`, `alt`,
+ * `caption`, or `code` key — with sync triggers computing the same
+ * extraction in SQL. The update trigger carries a WHEN guard so only real
+ * value changes re-tokenize; shipping the guard inside this rebuild spares
+ * existing sites a second full re-tokenization from a follow-up migration.
+ * Self-contained tables also retire the external-content
+ * `'delete'` choreography and its corruption modes (see migration 039).
+ * The rebuilt table keeps the collection's configured `tokenize` from
+ * search_config rather than resetting it to the default.
+ *
+ * The SQL emitted here MUST stay in lock-step with
+ * `FTSManager.createTriggers` / `createFtsTable` / `populateFromContent` in
+ * `src/search/fts-manager.ts`. If those change again, add a new migration
+ * rather than editing this one — migrations are forward-only.
+ *
+ * Postgres: no-op. FTS5 is SQLite-only.
+ *
+ * D1: idempotent at the granularity we care about (drop-then-create +
+ * repopulate with `INSERT OR REPLACE`, so concurrent migrators converge).
+ * A partial apply that drops the FTS table without recreating it is healed
+ * by the next `verifyAndRepairIndex` call at runtime.
+ */
+
+interface CollectionRow {
+	slug: string;
+	search_config: string | null;
+}
+
+interface FieldRow {
+	slug: string;
+	type: string;
+}
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!isSqlite(db)) return;
+
+	const collections = await sql<CollectionRow>`
+		SELECT slug, search_config FROM _emdash_collections
+		WHERE search_config IS NOT NULL
+	`.execute(db);
+
+	for (const collection of collections.rows) {
+		if (!isSearchEnabled(collection.search_config)) continue;
+
+		// Defensive re-validation before raw SQL interpolation, mirroring 039.
+		try {
+			validateIdentifier(collection.slug, "collection slug");
+		} catch (error) {
+			console.warn(
+				`[migration 064] skipping FTS rebuild for collection "${collection.slug}": ${
+					error instanceof Error ? error.message : String(error)
+				}`,
+			);
+			continue;
+		}
+
+		const fields = await getSearchableFields(db, collection.slug);
+		if (fields.length === 0) continue;
+
+		await rebuildIndex(db, collection.slug, fields, searchTokenizer(collection.search_config));
+	}
+}
+
+/**
+ * Forward-only. Down is a no-op: the FTS tables are managed by FTSManager
+ * at runtime and the self-contained shape remains fully functional for
+ * older code paths that only MATCH and join on id.
+ */
+export async function down(_db: Kysely<unknown>): Promise<void> {
+	// no-op
+}
+
+function isSearchEnabled(searchConfig: string | null): boolean {
+	if (!searchConfig) return false;
+	try {
+		const parsed: unknown = JSON.parse(searchConfig);
+		return (
+			typeof parsed === "object" &&
+			parsed !== null &&
+			"enabled" in parsed &&
+			parsed.enabled === true
+		);
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Tokenizers this migration knows how to carry across the rebuild — a frozen
+ * copy of SEARCH_TOKENIZERS as of this migration, not an import: a replay
+ * after the live allowlist changes must not reinterpret configs this
+ * migration never shipped with.
+ */
+const KNOWN_TOKENIZERS = ["porter unicode61", "unicode61", "trigram"];
+
+/**
+ * Tokenizer for the rebuilt table, from the collection's search_config.
+ * Values outside the allowlist (or unparsable config) fall back to the
+ * default rather than reaching the raw CREATE VIRTUAL TABLE statement.
+ */
+function searchTokenizer(searchConfig: string | null): string {
+	if (!searchConfig) return "porter unicode61";
+	try {
+		const parsed: unknown = JSON.parse(searchConfig);
+		if (typeof parsed === "object" && parsed !== null && "tokenize" in parsed) {
+			const configured = KNOWN_TOKENIZERS.find((tokenizer) => tokenizer === parsed.tokenize);
+			if (configured !== undefined) return configured;
+		}
+	} catch {
+		return "porter unicode61";
+	}
+	return "porter unicode61";
+}
+
+async function getSearchableFields(
+	db: Kysely<unknown>,
+	collectionSlug: string,
+): Promise<FieldRow[]> {
+	const rows = await sql<FieldRow>`
+		SELECT f.slug, f.type FROM _emdash_fields f
+		INNER JOIN _emdash_collections c ON c.id = f.collection_id
+		WHERE c.slug = ${collectionSlug} AND f.searchable = 1
+	`.execute(db);
+
+	const out: FieldRow[] = [];
+	for (const row of rows.rows) {
+		try {
+			validateIdentifier(row.slug, "searchable field name");
+			out.push(row);
+		} catch {
+			console.warn(
+				`[migration 064] skipping invalid searchable field "${row.slug}" on collection "${collectionSlug}"`,
+			);
+		}
+	}
+	return out;
+}
+
+/** Indexed-value expression for one field; lock-step with FTSManager.searchValueExpr. */
+function searchValueExpr(ref: string, fieldType: string): string {
+	if (fieldType !== "portableText") return ref;
+	return (
+		`CASE WHEN ${ref} IS NULL THEN NULL ` +
+		`WHEN json_valid(${ref}) AND json_type(${ref}) IN ('array', 'object') THEN (` +
+		`SELECT group_concat(j.value, ' ') FROM json_tree(${ref}) AS j ` +
+		`WHERE j.key IN ('text', 'alt', 'caption', 'code') AND j.type = 'text') ` +
+		`ELSE ${ref} END`
+	);
+}
+
+async function rebuildIndex(
+	db: Kysely<unknown>,
+	collectionSlug: string,
+	fields: FieldRow[],
+	tokenizer: string,
+): Promise<void> {
+	const ftsTable = `_emdash_fts_${collectionSlug}`;
+	const contentTable = `ec_${collectionSlug}`;
+	const slugs = fields.map((f) => f.slug);
+	const columnList = ["id UNINDEXED", "locale UNINDEXED", ...slugs].join(", ");
+	const fieldList = slugs.join(", ");
+	const newValueList = fields.map((f) => searchValueExpr(`NEW.${f.slug}`, f.type)).join(", ");
+	// The WHEN guard compares raw column values (null-safe IS NOT) so the
+	// update trigger fires only when an indexed value, the row's locale, or
+	// its trash state actually changed; without it every UPDATE re-tokenizes
+	// the whole document. deleted_at must stay in the guard or trash and
+	// restore stop syncing the index.
+	const changedCondition = ["deleted_at", "locale", ...slugs]
+		.map((f) => `OLD.${f} IS NOT NEW.${f}`)
+		.join(" OR ");
+	// Table-qualified: a bare column reference inside the json_tree extraction
+	// subquery binds to json_tree's own key/value/type/... columns.
+	const selectValueList = fields
+		.map((f) => searchValueExpr(`"${contentTable}"."${f.slug}"`, f.type))
+		.join(", ");
+
+	await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_insert"`).execute(db);
+	await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_update"`).execute(db);
+	await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_delete"`).execute(db);
+	await sql.raw(`DROP TABLE IF EXISTS "${ftsTable}"`).execute(db);
+
+	await sql
+		.raw(`
+		CREATE VIRTUAL TABLE IF NOT EXISTS "${ftsTable}" USING fts5(
+			${columnList},
+			tokenize='${tokenizer}'
+		)
+	`)
+		.execute(db);
+
+	await sql
+		.raw(`
+		CREATE TRIGGER IF NOT EXISTS "${ftsTable}_insert"
+		AFTER INSERT ON "${contentTable}"
+		WHEN NEW.deleted_at IS NULL
+		BEGIN
+			INSERT OR REPLACE INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+			VALUES (NEW.rowid, NEW.id, NEW.locale, ${newValueList});
+		END
+	`)
+		.execute(db);
+
+	await sql
+		.raw(`
+		CREATE TRIGGER IF NOT EXISTS "${ftsTable}_update"
+		AFTER UPDATE ON "${contentTable}"
+		WHEN ${changedCondition}
+		BEGIN
+			DELETE FROM "${ftsTable}" WHERE rowid = OLD.rowid;
+			INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+			SELECT NEW.rowid, NEW.id, NEW.locale, ${newValueList}
+			WHERE NEW.deleted_at IS NULL;
+		END
+	`)
+		.execute(db);
+
+	await sql
+		.raw(`
+		CREATE TRIGGER IF NOT EXISTS "${ftsTable}_delete"
+		AFTER DELETE ON "${contentTable}"
+		BEGIN
+			DELETE FROM "${ftsTable}" WHERE rowid = OLD.rowid;
+		END
+	`)
+		.execute(db);
+
+	await sql
+		.raw(`
+		INSERT OR REPLACE INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+		SELECT rowid, id, locale, ${selectValueList} FROM "${contentTable}"
+		WHERE deleted_at IS NULL
+	`)
+		.execute(db);
+}