dineway 0.1.8 → 0.1.11

package/dist/{registry-C0zjeB9P.mjs → registry-C-_hxLqa.mjs}

@@ -1,301 +1,13 @@
 import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
 import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
-import { a as isSqlite, c as tableExists, n as currentTimestamp, s as listTablesLike } from "./dialect-helpers-DhTzaUxP.mjs";
-import { t as withTransaction } from "./transaction-Cn2rjY78.mjs";
-import { i as RESERVED_FIELD_SLUGS, n as FIELD_TYPE_TO_COLUMN, r as RESERVED_COLLECTION_SLUGS } from "./types-COeOq9nK.mjs";
+import { c as tableExists, n as currentTimestamp, s as listTablesLike } from "./dialect-helpers-DhTzaUxP.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-D_jVet6z.mjs";
+import { t as withTransaction } from "./transaction-x2tJQ-A1.mjs";
+import { t as FTSManager } from "./fts-manager-B1pTNEG_.mjs";
+import { i as RESERVED_FIELD_SLUGS, n as FIELD_TYPE_TO_COLUMN, r as RESERVED_COLLECTION_SLUGS } from "./types-DL7Y8D_t.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 
-//#region src/search/fts-manager.ts
-/**
-* FTS5 Manager
-*
-* Handles creation, deletion, and management of FTS5 virtual tables
-* for full-text search on content collections.
-*/
-var FTSManager = class {
-	constructor(db) {
-		this.db = db;
-	}
-	/**
-	* Validate a collection slug and its searchable field names.
-	* Must be called before any raw SQL interpolation.
-	*/
-	validateInputs(collectionSlug, searchableFields) {
-		validateIdentifier(collectionSlug, "collection slug");
-		if (searchableFields) for (const field of searchableFields) validateIdentifier(field, "searchable field name");
-	}
-	/**
-	* Get the FTS table name for a collection
-	* Uses _dineway_ prefix to clearly mark as internal/system table
-	*/
-	getFtsTableName(collectionSlug) {
-		validateIdentifier(collectionSlug, "collection slug");
-		return `_dineway_fts_${collectionSlug}`;
-	}
-	/**
-	* Get the content table name for a collection
-	*/
-	getContentTableName(collectionSlug) {
-		validateIdentifier(collectionSlug, "collection slug");
-		return `ec_${collectionSlug}`;
-	}
-	/**
-	* Check if an FTS table exists for a collection
-	*/
-	async ftsTableExists(collectionSlug) {
-		const ftsTable = this.getFtsTableName(collectionSlug);
-		return tableExists(this.db, ftsTable);
-	}
-	/**
-	* Create an FTS5 virtual table for a collection.
-	* FTS5 is SQLite-only; on other dialects this is a no-op.
-	*
-	* @param collectionSlug - The collection slug
-	* @param searchableFields - Array of field names to index
-	* @param weights - Optional field weights for ranking
-	*/
-	async createFtsTable(collectionSlug, searchableFields, _weights) {
-		if (!isSqlite(this.db)) return;
-		this.validateInputs(collectionSlug, searchableFields);
-		const ftsTable = this.getFtsTableName(collectionSlug);
-		const contentTable = this.getContentTableName(collectionSlug);
-		const columns = [
-			"id UNINDEXED",
-			"locale UNINDEXED",
-			...searchableFields
-		].join(", ");
-		await sql.raw(`
-			CREATE VIRTUAL TABLE IF NOT EXISTS "${ftsTable}" USING fts5(
-				${columns},
-				content='${contentTable}',
-				content_rowid='rowid',
-				tokenize='porter unicode61'
-			)
-		`).execute(this.db);
-		await this.createTriggers(collectionSlug, searchableFields);
-	}
-	/**
-	* Create triggers to keep FTS table in sync with content table.
-	*
-	* Insert and update triggers only add rows to the FTS index when
-	* `deleted_at IS NULL`. This keeps soft-deleted content out of the
-	* index and keeps repair counts aligned with searchable content.
-	*/
-	async createTriggers(collectionSlug, searchableFields) {
-		this.validateInputs(collectionSlug, searchableFields);
-		const ftsTable = this.getFtsTableName(collectionSlug);
-		const contentTable = this.getContentTableName(collectionSlug);
-		const fieldList = searchableFields.join(", ");
-		const newFieldList = searchableFields.map((f) => `NEW.${f}`).join(", ");
-		await sql.raw(`
-			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_insert" 
-			AFTER INSERT ON "${contentTable}" 
-			WHEN NEW.deleted_at IS NULL
-			BEGIN
-				INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
-				VALUES (NEW.rowid, NEW.id, NEW.locale, ${newFieldList});
-			END
-		`).execute(this.db);
-		await sql.raw(`
-			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_update" 
-			AFTER UPDATE ON "${contentTable}" 
-			BEGIN
-				DELETE FROM "${ftsTable}" WHERE rowid = OLD.rowid;
-				INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
-				SELECT NEW.rowid, NEW.id, NEW.locale, ${newFieldList}
-				WHERE NEW.deleted_at IS NULL;
-			END
-		`).execute(this.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(this.db);
-	}
-	/**
-	* Drop triggers for a collection
-	*/
-	async dropTriggers(collectionSlug) {
-		this.validateInputs(collectionSlug);
-		const ftsTable = this.getFtsTableName(collectionSlug);
-		await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_insert"`).execute(this.db);
-		await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_update"`).execute(this.db);
-		await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_delete"`).execute(this.db);
-	}
-	/**
-	* Drop the FTS table and triggers for a collection
-	*/
-	async dropFtsTable(collectionSlug) {
-		if (!isSqlite(this.db)) return;
-		this.validateInputs(collectionSlug);
-		const ftsTable = this.getFtsTableName(collectionSlug);
-		await this.dropTriggers(collectionSlug);
-		await sql.raw(`DROP TABLE IF EXISTS "${ftsTable}"`).execute(this.db);
-	}
-	/**
-	* Rebuild the FTS index for a collection
-	*
-	* This is useful after bulk imports or if the index gets out of sync.
-	*/
-	async rebuildIndex(collectionSlug, searchableFields, weights) {
-		if (!isSqlite(this.db)) return;
-		await this.dropFtsTable(collectionSlug);
-		await this.createFtsTable(collectionSlug, searchableFields, weights);
-		await this.populateFromContent(collectionSlug, searchableFields);
-	}
-	/**
-	* Populate the FTS table from existing content
-	*/
-	async populateFromContent(collectionSlug, searchableFields) {
-		if (!isSqlite(this.db)) return;
-		this.validateInputs(collectionSlug, searchableFields);
-		const ftsTable = this.getFtsTableName(collectionSlug);
-		const contentTable = this.getContentTableName(collectionSlug);
-		const fieldList = searchableFields.join(", ");
-		await sql.raw(`
-			INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
-			SELECT rowid, id, locale, ${fieldList} FROM "${contentTable}"
-			WHERE deleted_at IS NULL
-		`).execute(this.db);
-	}
-	/**
-	* Get the search configuration for a collection
-	*/
-	async getSearchConfig(collectionSlug) {
-		const result = await this.db.selectFrom("_dineway_collections").select("search_config").where("slug", "=", collectionSlug).executeTakeFirst();
-		if (!result?.search_config) return null;
-		try {
-			const parsed = JSON.parse(result.search_config);
-			if (typeof parsed !== "object" || parsed === null || !("enabled" in parsed) || typeof parsed.enabled !== "boolean") return null;
-			const config = { enabled: parsed.enabled };
-			if ("weights" in parsed && typeof parsed.weights === "object" && parsed.weights !== null) {
-				const weights = {};
-				for (const [k, v] of Object.entries(parsed.weights)) if (typeof v === "number") weights[k] = v;
-				config.weights = weights;
-			}
-			return config;
-		} catch {
-			return null;
-		}
-	}
-	/**
-	* Update the search configuration for a collection
-	*/
-	async setSearchConfig(collectionSlug, config) {
-		await this.db.updateTable("_dineway_collections").set({ search_config: JSON.stringify(config) }).where("slug", "=", collectionSlug).execute();
-	}
-	/**
-	* Get searchable fields for a collection
-	*/
-	async getSearchableFields(collectionSlug) {
-		const collection = await this.db.selectFrom("_dineway_collections").select("id").where("slug", "=", collectionSlug).executeTakeFirst();
-		if (!collection) return [];
-		return (await this.db.selectFrom("_dineway_fields").select("slug").where("collection_id", "=", collection.id).where("searchable", "=", 1).execute()).map((f) => f.slug);
-	}
-	/**
-	* Enable search for a collection.
-	*
-	* Rebuilds from scratch to ensure stale tables or triggers do not survive
-	* repeated enablement.
-	*/
-	async enableSearch(collectionSlug, options) {
-		if (!isSqlite(this.db)) throw new Error("Full-text search is only available with SQLite databases");
-		const searchableFields = await this.getSearchableFields(collectionSlug);
-		if (searchableFields.length === 0) throw new Error(`No searchable fields defined for collection "${collectionSlug}". Mark at least one field as searchable before enabling search.`);
-		await this.rebuildIndex(collectionSlug, searchableFields, options?.weights);
-		await this.setSearchConfig(collectionSlug, {
-			enabled: true,
-			weights: options?.weights
-		});
-	}
-	/**
-	* Disable search for a collection
-	*
-	* Drops the FTS table and triggers.
-	*/
-	async disableSearch(collectionSlug) {
-		if (!isSqlite(this.db)) return;
-		const existing = await this.getSearchConfig(collectionSlug);
-		await this.dropFtsTable(collectionSlug);
-		await this.setSearchConfig(collectionSlug, {
-			enabled: false,
-			weights: existing?.weights
-		});
-	}
-	/**
-	* Get index statistics for a collection
-	*/
-	async getIndexStats(collectionSlug) {
-		if (!isSqlite(this.db)) return null;
-		this.validateInputs(collectionSlug);
-		const ftsDocsizeTable = `${this.getFtsTableName(collectionSlug)}_docsize`;
-		if (!await this.ftsTableExists(collectionSlug)) return null;
-		return { indexed: (await sql`
-			SELECT COUNT(*) as count FROM "${sql.raw(ftsDocsizeTable)}"
-		`.execute(this.db)).rows[0]?.count ?? 0 };
-	}
-	/**
-	* Verify FTS index integrity and rebuild if corrupted.
-	*
-	* Checks for row count mismatch between content table and FTS table.
-	*
-	* Returns true if the index was rebuilt, false if it was healthy.
-	*/
-	async verifyAndRepairIndex(collectionSlug) {
-		if (!isSqlite(this.db)) return false;
-		this.validateInputs(collectionSlug);
-		const ftsDocsizeTable = `${this.getFtsTableName(collectionSlug)}_docsize`;
-		const contentTable = this.getContentTableName(collectionSlug);
-		const fields = await this.getSearchableFields(collectionSlug);
-		const config = await this.getSearchConfig(collectionSlug);
-		if (!await this.ftsTableExists(collectionSlug)) {
-			if (!config?.enabled || fields.length === 0) return false;
-			console.warn(`FTS index for "${collectionSlug}" is missing. Rebuilding.`);
-			await this.rebuildIndex(collectionSlug, fields, config.weights);
-			return true;
-		}
-		const contentCount = await sql`
-			SELECT COUNT(*) as count FROM ${sql.ref(contentTable)}
-			WHERE deleted_at IS NULL
-		`.execute(this.db);
-		const ftsCount = await sql`
-			SELECT COUNT(*) as count FROM "${sql.raw(ftsDocsizeTable)}"
-		`.execute(this.db);
-		const contentRows = contentCount.rows[0]?.count ?? 0;
-		const ftsRows = ftsCount.rows[0]?.count ?? 0;
-		if (contentRows !== ftsRows) {
-			console.warn(`FTS index for "${collectionSlug}" has ${ftsRows} rows but content table has ${contentRows}. Rebuilding.`);
-			if (fields.length > 0) await this.rebuildIndex(collectionSlug, fields, config?.weights);
-			return true;
-		}
-		return false;
-	}
-	/**
-	* Verify and repair FTS indexes for all search-enabled collections.
-	*
-	* Intended to run at startup to auto-heal any corruption from
-	* previous process crashes.
-	*/
-	async verifyAndRepairAll() {
-		if (!isSqlite(this.db)) return 0;
-		const collections = await this.db.selectFrom("_dineway_collections").select("slug").where("search_config", "is not", null).execute();
-		let repaired = 0;
-		for (const { slug } of collections) {
-			if (!(await this.getSearchConfig(slug))?.enabled) continue;
-			try {
-				if (await this.verifyAndRepairIndex(slug)) repaired++;
-			} catch (error) {
-				console.error(`Failed to verify/repair FTS index for "${slug}":`, error);
-			}
-		}
-		return repaired;
-	}
-};
-
-//#endregion
 //#region src/schema/registry.ts
 var registry_exports = /* @__PURE__ */ __exportAll({
 	SchemaError: () => SchemaError,
@@ -366,6 +78,26 @@ var SchemaRegistry = class {
 		return (await this.db.selectFrom("_dineway_collections").selectAll().orderBy("slug", "asc").execute()).map(this.mapCollectionRow);
 	}
 	/**
+	* List all collections with their fields using bounded query shapes.
+	*/
+	async listCollectionsWithFields() {
+		const collections = (await this.db.selectFrom("_dineway_collections").selectAll().orderBy("slug", "asc").execute()).map(this.mapCollectionRow);
+		if (collections.length === 0) return [];
+		const fieldsByCollectionId = /* @__PURE__ */ new Map();
+		for (const collectionIdChunk of chunks(collections.map((collection) => collection.id), SQL_BATCH_SIZE)) {
+			const fieldRows = await this.db.selectFrom("_dineway_fields").selectAll().where("collection_id", "in", collectionIdChunk).orderBy("collection_id", "asc").orderBy("sort_order", "asc").orderBy("created_at", "asc").execute();
+			for (const field of fieldRows.map(this.mapFieldRow)) {
+				const existing = fieldsByCollectionId.get(field.collectionId);
+				if (existing) existing.push(field);
+				else fieldsByCollectionId.set(field.collectionId, [field]);
+			}
+		}
+		return collections.map((collection) => ({
+			...collection,
+			fields: fieldsByCollectionId.get(collection.id) ?? []
+		}));
+	}
+	/**
 	* Get a collection by slug
 	*/
 	async getCollection(slug) {
@@ -916,4 +648,4 @@ var SchemaRegistry = class {
 };
 
 //#endregion
-export { FTSManager as i, SchemaRegistry as n, registry_exports as r, SchemaError as t };
+export { SchemaRegistry as n, registry_exports as r, SchemaError as t };

package/dist/request-meta-Bd0mQfiS.mjs

@@ -0,0 +1,130 @@
+import { n as normalizeTrustedHeaders, t as getTrustedProxyHeaders } from "./trusted-proxy-Bi0Cuk5n.mjs";
+
+//#region src/plugins/request-meta.ts
+/**
+* Loose validation for IPv4 and IPv6 addresses.
+* Accepts digits, hex chars, dots, and colons — rejects anything else
+* (e.g. HTML tags, scripts, or other non-IP garbage in spoofed headers).
+*/
+const IP_PATTERN = /^[\da-fA-F.:]+$/;
+/**
+* Extract the first IP from an X-Forwarded-For header value.
+* The header may contain a comma-separated list of IPs; the first
+* entry is the original client IP.
+*
+* Returns null if the extracted value doesn't look like an IP address.
+*/
+function parseFirstForwardedIp(header) {
+	const trimmed = header.split(",")[0]?.trim();
+	if (!trimmed) return null;
+	return IP_PATTERN.test(trimmed) ? trimmed : null;
+}
+/**
+* Read an IP from an operator-declared trusted header. Forwarded-for style
+* headers are parsed as comma-separated lists and the first entry is used.
+*/
+function readIpFromHeader(headers, name) {
+	const value = headers.get(name);
+	if (!value) return null;
+	if (name.endsWith("forwarded-for")) return parseFirstForwardedIp(value);
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	return IP_PATTERN.test(trimmed) ? trimmed : null;
+}
+/**
+* Get the runtime-provided `cf` object from the request, if present.
+*/
+function getCfObject(request) {
+	return request.cf;
+}
+/**
+* Extract geographic information from the runtime-provided `cf` object
+* attached to the request.
+*/
+function extractGeo(cf) {
+	if (!cf) return null;
+	const country = cf.country ?? null;
+	const region = cf.region ?? null;
+	const city = cf.city ?? null;
+	if (country === null && region === null && city === null) return null;
+	return {
+		country,
+		region,
+		city
+	};
+}
+/**
+* Extract normalized request metadata from a Request object.
+*
+* IP resolution order:
+* 1. `CF-Connecting-IP` header — only trusted when a `cf` object is
+*    present on the request (proving the request came through a trusted
+*    edge/runtime that strips or overwrites client-supplied values).
+* 2. `X-Forwarded-For` header (first entry) — trusted only with runtime
+*    edge metadata.
+* 3. Operator-declared trusted proxy headers, tried in order.
+* 4. `null`
+*/
+function extractRequestMeta(request, configOrTrustedHeaders) {
+	const headers = request.headers;
+	const cf = getCfObject(request);
+	const trustedHeaders = resolveTrustedHeaders(configOrTrustedHeaders);
+	let ip = null;
+	if (cf) {
+		const cfIp = headers.get("cf-connecting-ip")?.trim();
+		if (cfIp && IP_PATTERN.test(cfIp)) ip = cfIp;
+	}
+	if (!ip && cf) {
+		const xff = headers.get("x-forwarded-for");
+		ip = xff ? parseFirstForwardedIp(xff) : null;
+	}
+	if (!ip) for (const name of trustedHeaders) {
+		const value = readIpFromHeader(headers, name);
+		if (value) {
+			ip = value;
+			break;
+		}
+	}
+	const userAgent = headers.get("user-agent")?.trim() || null;
+	const referer = headers.get("referer")?.trim() || null;
+	const geo = extractGeo(cf);
+	return {
+		ip,
+		userAgent,
+		referer,
+		geo
+	};
+}
+function resolveTrustedHeaders(value) {
+	if (Array.isArray(value)) return normalizeTrustedHeaders(value);
+	return getTrustedProxyHeaders(value);
+}
+/**
+* Headers that must never cross the RPC boundary to sandboxed plugins.
+* Session tokens, auth credentials, and infrastructure headers are stripped
+* to prevent malicious plugins from exfiltrating sensitive data.
+*/
+const SANDBOX_STRIPPED_HEADERS = new Set([
+	"cookie",
+	"set-cookie",
+	"authorization",
+	"proxy-authorization",
+	"cf-access-jwt-assertion",
+	"cf-access-client-id",
+	"cf-access-client-secret",
+	"x-dineway-request"
+]);
+/**
+* Copy request headers into a plain object, stripping sensitive headers
+* that must not be exposed to sandboxed plugin code.
+*/
+function sanitizeHeadersForSandbox(headers) {
+	const safe = {};
+	headers.forEach((value, key) => {
+		if (!SANDBOX_STRIPPED_HEADERS.has(key)) safe[key] = value;
+	});
+	return safe;
+}
+
+//#endregion
+export { sanitizeHeadersForSandbox as n, extractRequestMeta as t };

package/dist/review-requests-C2DIHwlJ.mjs

@@ -0,0 +1,148 @@
+import { n as decodeCursor, r as encodeCursor } from "./types-Bs6lTBBW.mjs";
+import { ulid } from "ulidx";
+
+//#region src/database/repositories/review-requests.ts
+var ReviewRequestRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async create(input) {
+		const id = ulid();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		await this.db.insertInto("_dineway_review_requests").values(toInsertableReviewRequest(id, input, now)).execute();
+		const request = await this.findById(id);
+		if (!request) throw new Error("Failed to create review request");
+		return request;
+	}
+	async findById(id) {
+		const row = await this.db.selectFrom("_dineway_review_requests").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? rowToReviewRequest(row) : null;
+	}
+	async list(query = {}) {
+		const limit = clampLimit(query.limit);
+		const rows = await this.queryRows(query).execute();
+		const items = rows.slice(0, limit).map(rowToReviewRequest);
+		const result = { items };
+		if (rows.length > limit && items.length > 0) {
+			const last = items.at(-1);
+			result.nextCursor = encodeCursor(last.createdAt, last.id);
+		}
+		return result;
+	}
+	async countPending(scope) {
+		let query = this.db.selectFrom("_dineway_review_requests").select((eb) => eb.fn.count("id").as("count")).where("status", "=", "pending");
+		if (scope) query = query.where("scope", "=", scope);
+		const result = await query.executeTakeFirst();
+		return Number(result?.count ?? 0);
+	}
+	async resolve(id, input) {
+		const resolvedAt = input.resolvedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		const result = await this.db.updateTable("_dineway_review_requests").set({
+			status: input.decision,
+			resolved_by_actor_type: input.resolvedByActorType,
+			resolved_by_actor_id: input.resolvedByActorId,
+			resolved_auth_metadata: jsonOrNull(input.resolvedAuthMetadata),
+			review_note: input.reviewNote ?? null,
+			resolved_at: resolvedAt,
+			updated_at: resolvedAt
+		}).where("id", "=", id).where("status", "=", "pending").executeTakeFirst();
+		if (Number(result.numUpdatedRows ?? 0) === 0) return null;
+		return this.findById(id);
+	}
+	async findApprovedForTarget(target) {
+		let query = this.db.selectFrom("_dineway_review_requests").selectAll().where("status", "=", "approved").where("collection", "=", target.collection).where("entry_id", "=", target.entryId).where("reviewed_rev", "=", target.reviewedRev).where("action_type", "=", target.actionType).where("action_hash", "=", target.actionHash).orderBy("resolved_at", "desc").orderBy("created_at", "desc").orderBy("id", "desc");
+		query = target.liveRevisionId === null ? query.where("live_revision_id", "is", null) : query.where("live_revision_id", "=", target.liveRevisionId);
+		query = target.draftRevisionId === null ? query.where("draft_revision_id", "is", null) : query.where("draft_revision_id", "=", target.draftRevisionId);
+		const row = await query.executeTakeFirst();
+		return row ? rowToReviewRequest(row) : null;
+	}
+	queryRows(query) {
+		const limit = clampLimit(query.limit);
+		let q = this.db.selectFrom("_dineway_review_requests").selectAll().orderBy("created_at", "desc").orderBy("id", "desc").limit(limit + 1);
+		if (query.status) q = q.where("status", "=", query.status);
+		if (query.collection) q = q.where("collection", "=", query.collection);
+		if (query.entryId) q = q.where("entry_id", "=", query.entryId);
+		if (query.scope) q = q.where("scope", "=", query.scope);
+		if (query.scopes && query.scopes.length > 0) q = q.where("scope", "in", query.scopes);
+		if (query.actionType) q = q.where("action_type", "=", query.actionType);
+		if (query.since) q = q.where("updated_at", ">=", query.since);
+		if (query.cursor) {
+			const decoded = decodeCursor(query.cursor);
+			if (decoded) q = q.where((eb) => eb.or([eb("created_at", "<", decoded.orderValue), eb.and([eb("created_at", "=", decoded.orderValue), eb("id", "<", decoded.id)])]));
+		}
+		return q;
+	}
+};
+function toInsertableReviewRequest(id, input, now) {
+	return {
+		id,
+		status: "pending",
+		collection: input.collection,
+		entry_id: input.entryId,
+		scope: input.scope ?? `content:${input.collection}:${input.entryId}`,
+		live_revision_id: input.liveRevisionId ?? null,
+		draft_revision_id: input.draftRevisionId ?? null,
+		reviewed_rev: input.reviewedRev,
+		action_type: input.actionType,
+		action_hash: input.actionHash,
+		risk_reason: input.riskReason ?? null,
+		review_payload: JSON.stringify(input.reviewPayload),
+		requested_by_actor_type: input.requestedByActorType,
+		requested_by_actor_id: input.requestedByActorId,
+		requested_auth_metadata: jsonOrNull(input.requestedAuthMetadata),
+		resolved_by_actor_type: null,
+		resolved_by_actor_id: null,
+		resolved_auth_metadata: null,
+		review_note: null,
+		created_at: input.createdAt ?? now,
+		updated_at: input.createdAt ?? now,
+		resolved_at: null
+	};
+}
+function rowToReviewRequest(row) {
+	return {
+		id: row.id,
+		status: row.status,
+		collection: row.collection,
+		entryId: row.entry_id,
+		scope: row.scope,
+		liveRevisionId: row.live_revision_id,
+		draftRevisionId: row.draft_revision_id,
+		reviewedRev: row.reviewed_rev,
+		actionType: row.action_type,
+		actionHash: row.action_hash,
+		riskReason: row.risk_reason,
+		reviewPayload: parseRecord(row.review_payload) ?? {},
+		requestedByActorType: row.requested_by_actor_type,
+		requestedByActorId: row.requested_by_actor_id,
+		requestedAuthMetadata: parseRecord(row.requested_auth_metadata),
+		resolvedByActorType: row.resolved_by_actor_type,
+		resolvedByActorId: row.resolved_by_actor_id,
+		resolvedAuthMetadata: parseRecord(row.resolved_auth_metadata),
+		reviewNote: row.review_note,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		resolvedAt: row.resolved_at
+	};
+}
+function jsonOrNull(value) {
+	return value ? JSON.stringify(value) : null;
+}
+function parseRecord(value) {
+	if (!value) return null;
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clampLimit(value) {
+	return Math.min(Math.max(1, value ?? 50), 100);
+}
+
+//#endregion
+export { ReviewRequestRepository as t };

package/dist/review-requests-DIyjw-K_.mjs

@@ -0,0 +1,79 @@
+import { t as ReviewRequestRepository } from "./review-requests-C2DIHwlJ.mjs";
+
+//#region src/api/handlers/review-requests.ts
+async function handleReviewRequestList(db, query) {
+	try {
+		return {
+			success: true,
+			data: await new ReviewRequestRepository(db).list(query)
+		};
+	} catch (error) {
+		console.error("Review request list error:", error);
+		return {
+			success: false,
+			error: {
+				code: "REVIEW_REQUEST_LIST_ERROR",
+				message: "Failed to list review requests"
+			}
+		};
+	}
+}
+async function handleReviewRequestGet(db, id) {
+	try {
+		const item = await new ReviewRequestRepository(db).findById(id);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Review request not found"
+			}
+		};
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		console.error("Review request get error:", error);
+		return {
+			success: false,
+			error: {
+				code: "REVIEW_REQUEST_GET_ERROR",
+				message: "Failed to fetch review request"
+			}
+		};
+	}
+}
+async function handleReviewRequestResolve(db, id, input) {
+	try {
+		const item = await new ReviewRequestRepository(db).resolve(id, {
+			decision: input.decision,
+			reviewNote: input.reviewNote,
+			resolvedByActorType: input.actor.actorType,
+			resolvedByActorId: input.actor.actorId,
+			resolvedAuthMetadata: input.actor.authMetadata
+		});
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Review request not found or already resolved"
+			}
+		};
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		console.error("Review request resolve error:", error);
+		return {
+			success: false,
+			error: {
+				code: "REVIEW_REQUEST_RESOLVE_ERROR",
+				message: "Failed to resolve review request"
+			}
+		};
+	}
+}
+
+//#endregion
+export { handleReviewRequestList as n, handleReviewRequestResolve as r, handleReviewRequestGet as t };