@manablox/db 0.3.0 → 0.4.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { A as menusRelations, B as accounts, C as spaces, D as contentsRelations, E as assetsRelations, F as menus, G as users, H as memberships, I as contentTypes, J as assetVariants, K as verifications, L as contentVersions, M as spacesRelations, N as usersRelations, O as membershipsRelations, P as menuItems, R as contents, S as webhooks, T as assetVariantsRelations, U as roles, V as apikeys, W as sessions, Y as assets, _ as index_d_exports, a as ContentRow, b as workflows, c as MembershipRow, d as PushSubscriptionRow, f as RoleRow, g as WorkflowRunRow, h as WorkflowRow, i as ContentInsert, j as rolesRelations, k as menuItemsRelations, l as MenuItemRow, m as UserRow, n as AssetUsageRow, o as ContentTypeRow, p as SpaceRow, q as assetUsages, r as AssetVariantRow, s as ContentVersionRow, t as AssetRow, u as MenuRow, v as pushSubscriptions, w as assetUsagesRelations, x as webhookDeliveries, y as workflowRuns, z as publishedContents } from "./index-rZ24t-Ln.js";
-import { A as AssetRepository, B as buildContentWhere, C as ContentRepository, D as buildTree, E as TreeNode, F as ContentSort, G as Executor, H as Database, I as ContentTable, J as createDatabase, K as Sql, L as FieldFilter, M as Paginated, N as paginate, O as AssetUsageRepository, P as ContentFilter, R as Pagination, S as ContentTypeRepository, T as SQL, U as DatabaseHandle, V as buildOrderBy, W as DatabaseOptions, _ as MenuItemInput, a as WorkflowRunCreateData, b as MenuWriteData, c as WebhookDeliveryRow, d as SpaceRole, f as UserCreateData, g as SpaceWriteData, h as SpaceRepository, i as WorkflowRepository, j as AssetWriteData, k as AssetFilter, l as WebhookRepository, m as UserUpdateData, n as createRepositories, o as WorkflowWriteData, p as UserRepository, q as Transaction, r as RUNS_KEPT_PER_WORKFLOW, s as WebhookDeliveryData, t as Repositories, u as WebhookRow, v as MenuItemNode, w as ContentWriteData, x as ResolvedMenuItem, y as MenuRepository, z as PgColumn } from "./index-Cyf_N5K3.js";
+import { $ as assetUsages, A as contentsRelations, B as menus, C as workflows, D as assetUsagesRelations, E as spaces, F as spacesRelations, G as accounts, H as contentVersions, I as usersRelations, J as roles, K as apikeys, L as contentApprovals, M as menuItemsRelations, N as menusRelations, O as assetVariantsRelations, P as rolesRelations, Q as auditEntries, R as notifications, S as workflowRuns, T as webhooks, U as contents, V as contentTypes, W as publishedContents, X as users, Y as sessions, Z as verifications, _ as UserRow, a as ContentApprovalRow, b as index_d_exports, c as ContentTypeRow, d as MenuItemRow, et as assetVariants, f as MenuRow, g as SpaceRow, h as RoleRow, i as AuditEntryRow, j as membershipsRelations, k as assetsRelations, l as ContentVersionRow, m as PushSubscriptionRow, n as AssetUsageRow, o as ContentInsert, p as NotificationRow, q as memberships, r as AssetVariantRow, s as ContentRow, t as AssetRow, tt as assets, u as MembershipRow, v as WorkflowRow, w as webhookDeliveries, x as pushSubscriptions, y as WorkflowRunRow, z as menuItems } from "./index-DrNMGM9N.js";
+import { $ as Pagination, A as ContentApprovalRepository, B as AuditRepositoryOptions, C as MenuItemNode, D as ContentTypeRepository, E as ResolvedMenuItem, F as TreeNode, G as AssetRepository, H as AuditVerification, I as buildTree, J as paginate, K as AssetWriteData, L as AuditAppendInput, M as ContentRepository, N as ContentWriteData, O as ApprovalDecisionData, P as SQL, Q as FieldFilter, R as AuditFilter, S as MenuItemInput, T as MenuWriteData, U as AssetUsageRepository, V as AuditSort, W as AssetFilter, X as ContentSort, Y as ContentFilter, Z as ContentTable, _ as SpaceRepository, a as WorkflowRepository, at as DatabaseOptions, b as NotificationInsert, c as WebhookDeliveryData, ct as Transaction, d as WebhookRow, et as PgColumn, f as WebhookWriteData, g as UserUpdateData, h as UserRepository, i as RUNS_KEPT_PER_WORKFLOW, it as DatabaseHandle, j as PendingApproval, k as ApprovalRequestData, l as WebhookDeliveryRow, lt as createDatabase, m as UserCreateData, n as RepositoriesOptions, nt as buildOrderBy, o as WorkflowRunCreateData, ot as Executor, p as SpaceRole, q as Paginated, r as createRepositories, rt as Database, s as WorkflowWriteData, st as Sql, t as Repositories, tt as buildContentWhere, u as WebhookRepository, v as SpaceWriteData, w as MenuRepository, x as NotificationRepository, y as NotificationFilter, z as AuditRepository } from "./index-BLAkQMJT.js";
 import { ErrorKey } from "@manablox/core";
 //#region src/bootstrap.d.ts
 /**
@@ -120,4 +120,4 @@ export declare const MIGRATIONS_FOLDER: string;
  */
 export declare function runMigrations(handle: DatabaseHandle): Promise<void>;
 //#endregion
-export { AssetFilter, AssetRepository, AssetRow, AssetUsageRepository, AssetUsageRow, AssetVariantRow, AssetWriteData, ContentFilter, ContentInsert, ContentRepository, ContentRow, ContentSort, ContentTable, ContentTypeRepository, ContentTypeRow, ContentVersionRow, ContentWriteData, Database, DatabaseHandle, DatabaseOptions, Executor, FieldFilter, MembershipRow, MenuItemInput, MenuItemNode, MenuItemRow, MenuRepository, MenuRow, MenuWriteData, Paginated, Pagination, type PgColumn, PushSubscriptionRow, RUNS_KEPT_PER_WORKFLOW, Repositories, ResolvedMenuItem, RoleRow, type SQL, SpaceRepository, SpaceRole, SpaceRow, SpaceWriteData, Sql, Transaction, TreeNode, UserCreateData, UserRepository, UserRow, UserUpdateData, WebhookDeliveryData, WebhookDeliveryRow, WebhookRepository, WebhookRow, WorkflowRepository, WorkflowRow, WorkflowRunCreateData, WorkflowRunRow, WorkflowWriteData, accounts, apikeys, assetUsages, assetUsagesRelations, assetVariants, assetVariantsRelations, assets, assetsRelations, buildContentWhere, buildOrderBy, buildTree, contentTypes, contentVersions, contents, contentsRelations, createDatabase, createRepositories, memberships, membershipsRelations, menuItems, menuItemsRelations, menus, menusRelations, paginate, publishedContents, pushSubscriptions, roles, rolesRelations, index_d_exports as schema, sessions, spaces, spacesRelations, users, usersRelations, verifications, webhookDeliveries, webhooks, workflowRuns, workflows };
+export { ApprovalDecisionData, ApprovalRequestData, AssetFilter, AssetRepository, AssetRow, AssetUsageRepository, AssetUsageRow, AssetVariantRow, AssetWriteData, AuditAppendInput, AuditEntryRow, AuditFilter, AuditRepository, AuditRepositoryOptions, AuditSort, AuditVerification, ContentApprovalRepository, ContentApprovalRow, ContentFilter, ContentInsert, ContentRepository, ContentRow, ContentSort, ContentTable, ContentTypeRepository, ContentTypeRow, ContentVersionRow, ContentWriteData, Database, DatabaseHandle, DatabaseOptions, Executor, FieldFilter, MembershipRow, MenuItemInput, MenuItemNode, MenuItemRow, MenuRepository, MenuRow, MenuWriteData, NotificationFilter, NotificationInsert, NotificationRepository, NotificationRow, Paginated, Pagination, PendingApproval, type PgColumn, PushSubscriptionRow, RUNS_KEPT_PER_WORKFLOW, Repositories, RepositoriesOptions, ResolvedMenuItem, RoleRow, type SQL, SpaceRepository, SpaceRole, SpaceRow, SpaceWriteData, Sql, Transaction, TreeNode, UserCreateData, UserRepository, UserRow, UserUpdateData, WebhookDeliveryData, WebhookDeliveryRow, WebhookRepository, WebhookRow, WebhookWriteData, WorkflowRepository, WorkflowRow, WorkflowRunCreateData, WorkflowRunRow, WorkflowWriteData, accounts, apikeys, assetUsages, assetUsagesRelations, assetVariants, assetVariantsRelations, assets, assetsRelations, auditEntries, buildContentWhere, buildOrderBy, buildTree, contentApprovals, contentTypes, contentVersions, contents, contentsRelations, createDatabase, createRepositories, memberships, membershipsRelations, menuItems, menuItemsRelations, menus, menusRelations, notifications, paginate, publishedContents, pushSubscriptions, roles, rolesRelations, index_d_exports as schema, sessions, spaces, spacesRelations, users, usersRelations, verifications, webhookDeliveries, webhooks, workflowRuns, workflows };

package/dist/index.js

@@ -1,5 +1,5 @@
-import { _ as applyBootstrapSql, a as UserRepository, c as ContentTypeRepository, d as AssetUsageRepository, f as AssetRepository, g as createDatabase, h as paginate, i as WebhookRepository, l as ContentRepository, m as buildOrderBy, n as RUNS_KEPT_PER_WORKFLOW, o as SpaceRepository, p as buildContentWhere, r as WorkflowRepository, s as MenuRepository, t as createRepositories, u as buildTree } from "./repositories-DYjzuuF6.js";
-import { A as contentVersions, B as tsvector, C as roles, D as assetUsages, E as verifications, F as idToLabel, I as labelToId, L as ltree, M as publishedContents, N as spaces, O as assetVariants, P as buildPath, R as parsePath, S as memberships, T as users, _ as menuItems, a as webhookDeliveries, b as accounts, c as assetVariantsRelations, d as membershipsRelations, f as menuItemsRelations, g as usersRelations, h as spacesRelations, i as workflows, j as contents, k as assets, l as assetsRelations, m as rolesRelations, n as pushSubscriptions, o as webhooks, p as menusRelations, r as workflowRuns, s as assetUsagesRelations, t as schema_exports, u as contentsRelations, v as menus, w as sessions, x as apikeys, y as contentTypes, z as pathDepth } from "./schema-Bb4p16Yz.js";
+import { _ as buildOrderBy, a as UserRepository, b as applyBootstrapSql, c as MenuRepository, d as ContentRepository, f as buildTree, g as buildContentWhere, h as AssetRepository, i as WebhookRepository, l as ContentTypeRepository, m as AssetUsageRepository, n as RUNS_KEPT_PER_WORKFLOW, o as SpaceRepository, p as AuditRepository, r as WorkflowRepository, s as NotificationRepository, t as createRepositories, u as ContentApprovalRepository, v as paginate, y as createDatabase } from "./repositories-pz4NeWaF.js";
+import { A as assetUsages, B as ltree, C as apikeys, D as users, E as sessions, F as publishedContents, H as pathDepth, I as spaces, L as buildPath, M as assets, N as contentVersions, O as verifications, P as contents, R as idToLabel, S as accounts, T as roles, U as tsvector, V as parsePath, _ as contentApprovals, a as webhookDeliveries, b as menus, c as assetVariantsRelations, d as membershipsRelations, f as menuItemsRelations, g as usersRelations, h as spacesRelations, i as workflows, j as assetVariants, k as auditEntries, l as assetsRelations, m as rolesRelations, n as pushSubscriptions, o as webhooks, p as menusRelations, r as workflowRuns, s as assetUsagesRelations, t as schema_exports, u as contentsRelations, v as notifications, w as memberships, x as contentTypes, y as menuItems, z as labelToId } from "./schema-Dm3RcBst.js";
 import { ManabloxError } from "@manablox/core";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -57,4 +57,4 @@ async function runMigrations(handle) {
 	await migrate(handle.db, { migrationsFolder: MIGRATIONS_FOLDER });
 }
 //#endregion
-export { AssetRepository, AssetUsageRepository, ContentRepository, ContentTypeRepository, MIGRATIONS_FOLDER, MenuRepository, RUNS_KEPT_PER_WORKFLOW, SpaceRepository, UserRepository, WebhookRepository, WorkflowRepository, accounts, apikeys, applyBootstrapSql, assetUsages, assetUsagesRelations, assetVariants, assetVariantsRelations, assets, assetsRelations, buildContentWhere, buildOrderBy, buildPath, buildTree, contentTypes, contentVersions, contents, contentsRelations, createDatabase, createRepositories, idToLabel, isUniqueViolation, labelToId, ltree, memberships, membershipsRelations, menuItems, menuItemsRelations, menus, menusRelations, paginate, parsePath, pathDepth, publishedContents, pushSubscriptions, rethrowUniqueViolation, roles, rolesRelations, runMigrations, schema_exports as schema, sessions, spaces, spacesRelations, tsvector, uniqueViolation, users, usersRelations, verifications, webhookDeliveries, webhooks, workflowRuns, workflows };
+export { AssetRepository, AssetUsageRepository, AuditRepository, ContentApprovalRepository, ContentRepository, ContentTypeRepository, MIGRATIONS_FOLDER, MenuRepository, NotificationRepository, RUNS_KEPT_PER_WORKFLOW, SpaceRepository, UserRepository, WebhookRepository, WorkflowRepository, accounts, apikeys, applyBootstrapSql, assetUsages, assetUsagesRelations, assetVariants, assetVariantsRelations, assets, assetsRelations, auditEntries, buildContentWhere, buildOrderBy, buildPath, buildTree, contentApprovals, contentTypes, contentVersions, contents, contentsRelations, createDatabase, createRepositories, idToLabel, isUniqueViolation, labelToId, ltree, memberships, membershipsRelations, menuItems, menuItemsRelations, menus, menusRelations, notifications, paginate, parsePath, pathDepth, publishedContents, pushSubscriptions, rethrowUniqueViolation, roles, rolesRelations, runMigrations, schema_exports as schema, sessions, spaces, spacesRelations, tsvector, uniqueViolation, users, usersRelations, verifications, webhookDeliveries, webhooks, workflowRuns, workflows };

package/dist/{repositories-DYjzuuF6.js → repositories-pz4NeWaF.js}

@@ -1,8 +1,8 @@
-import { A as contentVersions, C as roles, D as assetUsages, F as idToLabel, M as publishedContents, N as spaces, O as assetVariants, S as memberships, T as users, _ as menuItems, a as webhookDeliveries, b as accounts, i as workflows, j as contents, k as assets, n as pushSubscriptions, o as webhooks, r as workflowRuns, t as schema_exports, v as menus, w as sessions, y as contentTypes } from "./schema-Bb4p16Yz.js";
+import { A as assetUsages, D as users, E as sessions, F as publishedContents, I as spaces, M as assets, N as contentVersions, P as contents, R as idToLabel, S as accounts, T as roles, _ as contentApprovals, a as webhookDeliveries, b as menus, i as workflows, j as assetVariants, k as auditEntries, n as pushSubscriptions, o as webhooks, r as workflowRuns, t as schema_exports, v as notifications, w as memberships, x as contentTypes, y as menuItems } from "./schema-Dm3RcBst.js";
 import { drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
-import { and, asc, desc, eq, getTableColumns, gte, inArray, isNull, lt, lte, notInArray, or, sql } from "drizzle-orm";
-import { ManabloxError, defineContentType } from "@manablox/core";
+import { and, asc, desc, eq, getTableColumns, gt, gte, ilike, inArray, isNull, lt, lte, notInArray, or, sql } from "drizzle-orm";
+import { ManabloxError, currentActor, defineContentType, hashAuditEntry } from "@manablox/core";
 import { randomUUID } from "node:crypto";
 //#region src/bootstrap.ts
 /**
@@ -59,7 +59,7 @@ async function paginate(db, table, options) {
 }
 //#endregion
 //#region src/query.ts
-const SORT_COLUMNS = {
+const SORT_COLUMNS$1 = {
 	position: "position",
 	title: "title",
 	createdAt: "created_at",
@@ -101,9 +101,9 @@ function buildFieldCondition(table, filter, typeIds, registry) {
 		case "lte": return sql`(${text})::numeric <= ${asNumber(filter.value)}`;
 		case "gt": return sql`(${text})::numeric > ${asNumber(filter.value)}`;
 		case "gte": return sql`(${text})::numeric >= ${asNumber(filter.value)}`;
-		case "contains": return sql`${text} ilike ${`%${escapeLike(String(filter.value ?? ""))}%`}`;
-		case "startsWith": return sql`${text} ilike ${`${escapeLike(String(filter.value ?? ""))}%`}`;
-		case "endsWith": return sql`${text} ilike ${`%${escapeLike(String(filter.value ?? ""))}`}`;
+		case "contains": return sql`${text} ilike ${`%${escapeLike$1(String(filter.value ?? ""))}%`}`;
+		case "startsWith": return sql`${text} ilike ${`${escapeLike$1(String(filter.value ?? ""))}%`}`;
+		case "endsWith": return sql`${text} ilike ${`%${escapeLike$1(String(filter.value ?? ""))}`}`;
 		case "isNull": return sql`(${path} is null or ${path} = 'null'::jsonb)`;
 		case "isNotNull": return sql`(${path} is not null and ${path} <> 'null'::jsonb)`;
 		default: {
@@ -128,12 +128,12 @@ function assertOperatorAllowed(filter, typeIds, registry) {
 function buildOrderBy(sorts) {
 	if (sorts.length === 0) return sql`${sql.identifier("position")} asc, ${sql.identifier("created_at")} asc`;
 	return sorts.map((sort) => {
-		const column = SORT_COLUMNS[sort.by];
+		const column = SORT_COLUMNS$1[sort.by];
 		if (!column) throw ManabloxError.badRequest("query.sort.unsupported", { by: sort.by });
 		return sql`${sql.identifier(column)} ${sql.raw(sort.direction === "desc" ? "desc" : "asc")}`;
 	}).reduce((acc, part) => sql`${acc}, ${part}`);
 }
-const escapeLike = (value) => value.replace(/[%_\\]/g, (c) => `\\${c}`);
+const escapeLike$1 = (value) => value.replace(/[%_\\]/g, (c) => `\\${c}`);
 function asStringArray(value) {
 	if (!Array.isArray(value)) throw ManabloxError.badRequest("query.value.expectedArray");
 	return value.map((entry) => String(entry));
@@ -210,6 +210,13 @@ var AssetRepository = class {
 		const [row] = await this.db.delete(assets).where(eq(assets.id, id)).returning();
 		return row ?? null;
 	}
+	/** Timestamps an import carries over; `create()` can only stamp the moment of import. */
+	async restoreTimestamps(id, createdAt, updatedAt) {
+		await this.db.update(assets).set({
+			createdAt,
+			updatedAt
+		}).where(eq(assets.id, id));
+	}
 	async variants(assetIds) {
 		if (assetIds.length === 0) return [];
 		return this.db.select().from(assetVariants).where(inArray(assetVariants.assetId, assetIds));
@@ -359,6 +366,189 @@ var AssetUsageRepository = class {
 	}
 };
 //#endregion
+//#region src/repositories/audit.ts
+const SORT_COLUMNS = {
+	at: auditEntries.at,
+	action: auditEntries.action,
+	actorLabel: auditEntries.actorLabel,
+	targetKind: auditEntries.targetKind,
+	targetLabel: auditEntries.targetLabel
+};
+const escapeLike = (value) => value.replace(/[%_\\]/g, (c) => `\\${c}`);
+/**
+* Appends to and reads the audit log. There is no update and no delete: the table
+* refuses both, so this class offers neither.
+*/
+var AuditRepository = class {
+	db;
+	options;
+	constructor(db, options = {}) {
+		this.db = db;
+		this.options = options;
+	}
+	/**
+	* Writes one entry, chained to the last. Writers are serialised on a transaction-level
+	* advisory lock, so two entries can never both claim the same predecessor; the lock
+	* is held for one read and one insert.
+	*/
+	async append(input) {
+		const row = await this.write(input);
+		if (this.options.onAppended) try {
+			this.options.onAppended(row);
+		} catch (error) {
+			this.options.onError?.(error, input);
+		}
+		return row;
+	}
+	async write(input) {
+		const actor = input.actor ?? currentActor();
+		const at = input.at ?? /* @__PURE__ */ new Date();
+		const changes = input.changes ?? [];
+		const meta = input.meta ?? null;
+		const actorDetail = actor.detail ?? null;
+		return this.db.transaction(async (tx) => {
+			await tx.execute(sql`select pg_advisory_xact_lock(hashtext('audit_entries'))`);
+			const [last] = await tx.select({ hash: auditEntries.hash }).from(auditEntries).orderBy(desc(auditEntries.seq)).limit(1);
+			const prevHash = last?.hash ?? null;
+			const content = {
+				at,
+				spaceId: input.spaceId ?? null,
+				actorKind: actor.kind,
+				actorId: actor.id,
+				actorLabel: actor.label,
+				actorDetail,
+				action: input.action,
+				targetKind: input.targetKind,
+				targetId: input.targetId ?? null,
+				targetLabel: input.targetLabel ?? null,
+				changes,
+				meta,
+				prevHash
+			};
+			const [row] = await tx.insert(auditEntries).values({
+				...content,
+				hash: hashAuditEntry(content)
+			}).returning();
+			if (!row) throw new ManabloxError("audit.append.failed");
+			return row;
+		});
+	}
+	/**
+	* `append` that never throws. The write it describes has already happened; failing
+	* the request now would report an error for something that succeeded, so the failure
+	* is reported to `onError` (the host logs it) and the caller carries on.
+	*/
+	async record(input) {
+		try {
+			return await this.append(input);
+		} catch (error) {
+			this.options.onError?.(error, input);
+			return null;
+		}
+	}
+	async findById(id) {
+		return (await this.db.select().from(auditEntries).where(eq(auditEntries.id, id)).limit(1))[0] ?? null;
+	}
+	list(filter, sort = {
+		by: "at",
+		direction: "desc"
+	}, pagination = {
+		limit: 50,
+		offset: 0
+	}) {
+		const column = SORT_COLUMNS[sort.by];
+		const primary = sort.direction === "asc" ? asc(column) : desc(column);
+		const tiebreak = sort.direction === "asc" ? asc(auditEntries.seq) : desc(auditEntries.seq);
+		return paginate(this.db, auditEntries, {
+			where: buildWhere(filter),
+			orderBy: [primary, tiebreak],
+			pagination
+		});
+	}
+	/** The entries about one thing, oldest first: a document's history. */
+	forTarget(targetKind, targetId, limit = 100) {
+		return this.db.select().from(auditEntries).where(and(eq(auditEntries.targetKind, targetKind), eq(auditEntries.targetId, targetId))).orderBy(desc(auditEntries.seq)).limit(limit);
+	}
+	/**
+	* Recomputes every hash from the first entry on and checks each link to its
+	* predecessor. The chain is one across the instance, so this walks all of it, in
+	* batches; on a large log it takes a while and that is the point.
+	*/
+	async verify(batchSize = 500) {
+		let prevHash = null;
+		let afterSeq = 0;
+		let checked = 0;
+		for (;;) {
+			const rows = await this.db.select().from(auditEntries).where(gt(auditEntries.seq, afterSeq)).orderBy(asc(auditEntries.seq)).limit(batchSize);
+			if (rows.length === 0) break;
+			for (const row of rows) {
+				checked++;
+				if (row.prevHash !== prevHash) return {
+					ok: false,
+					checked,
+					brokenAt: {
+						seq: row.seq,
+						id: row.id,
+						reason: "link"
+					}
+				};
+				if (hashAuditEntry({
+					at: row.at,
+					spaceId: row.spaceId,
+					actorKind: row.actorKind,
+					actorId: row.actorId,
+					actorLabel: row.actorLabel,
+					actorDetail: row.actorDetail,
+					action: row.action,
+					targetKind: row.targetKind,
+					targetId: row.targetId,
+					targetLabel: row.targetLabel,
+					changes: row.changes,
+					meta: row.meta,
+					prevHash: row.prevHash
+				}) !== row.hash) return {
+					ok: false,
+					checked,
+					brokenAt: {
+						seq: row.seq,
+						id: row.id,
+						reason: "hash"
+					}
+				};
+				prevHash = row.hash;
+				afterSeq = row.seq;
+			}
+		}
+		return {
+			ok: true,
+			checked,
+			brokenAt: null
+		};
+	}
+	async count(filter = {}) {
+		const [row] = await this.db.select({ count: sql`count(*)::int` }).from(auditEntries).where(buildWhere(filter));
+		return row?.count ?? 0;
+	}
+};
+function buildWhere(filter) {
+	const conditions = [];
+	if (filter.spaceId === null) conditions.push(isNull(auditEntries.spaceId));
+	else if (filter.spaceId) conditions.push(eq(auditEntries.spaceId, filter.spaceId));
+	if (filter.actorKind) conditions.push(eq(auditEntries.actorKind, filter.actorKind));
+	if (filter.actorId) conditions.push(eq(auditEntries.actorId, filter.actorId));
+	if (filter.actions?.length) conditions.push(inArray(auditEntries.action, filter.actions));
+	if (filter.targetKind) conditions.push(eq(auditEntries.targetKind, filter.targetKind));
+	if (filter.targetId) conditions.push(eq(auditEntries.targetId, filter.targetId));
+	if (filter.from) conditions.push(gte(auditEntries.at, filter.from));
+	if (filter.to) conditions.push(lte(auditEntries.at, filter.to));
+	if (filter.search?.trim()) {
+		const term = `%${escapeLike(filter.search.trim())}%`;
+		const match = or(ilike(auditEntries.actorLabel, term), ilike(auditEntries.targetLabel, term), ilike(auditEntries.action, term));
+		if (match) conditions.push(match);
+	}
+	return conditions.length ? and(...conditions) : void 0;
+}
+//#endregion
 //#region src/repositories/content.ts
 /**
 * The columns `publish()` copies from the draft into the projection: every column the
@@ -745,6 +935,31 @@ var ContentRepository = class {
 	async versionSnapshot(contentId, version) {
 		return (await this.db.select({ snapshot: contentVersions.snapshot }).from(contentVersions).where(and(eq(contentVersions.contentId, contentId), eq(contentVersions.version, version))).limit(1))[0]?.snapshot ?? null;
 	}
+	/** Every stored version of these documents, oldest first, for a space export. */
+	async history(contentIds) {
+		if (contentIds.length === 0) return [];
+		return this.db.select().from(contentVersions).where(inArray(contentVersions.contentId, contentIds)).orderBy(contentVersions.contentId, contentVersions.version);
+	}
+	/**
+	* Puts an imported document back the way its source had it: the version counter and
+	* timestamps `create()` had to invent, and the version history in place of the single
+	* snapshot `create()` wrote. The row's own columns are left alone otherwise.
+	*/
+	async restoreHistory(id, data) {
+		await this.db.transaction(async (tx) => {
+			await tx.update(contents).set({
+				version: data.version,
+				createdAt: data.createdAt,
+				updatedAt: data.updatedAt
+			}).where(eq(contents.id, id));
+			if (data.versions.length === 0) return;
+			await tx.delete(contentVersions).where(eq(contentVersions.contentId, id));
+			await tx.insert(contentVersions).values(data.versions.map((version) => ({
+				...version,
+				contentId: id
+			})));
+		});
+	}
 	async snapshot(db, row, actorId) {
 		await db.insert(contentVersions).values({
 			contentId: row.id,
@@ -809,6 +1024,79 @@ function joinSegment(prefix, segment) {
 	return prefix ? `${prefix}/${segment}` : segment;
 }
 //#endregion
+//#region src/repositories/content-approval.ts
+/**
+* The approval history of documents. Rows are appended when someone asks and closed
+* when someone decides; the "one pending per document" rule is the service's, this
+* only offers the reads it needs to keep it.
+*/
+var ContentApprovalRepository = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	async findById(id) {
+		return (await this.db.select().from(contentApprovals).where(eq(contentApprovals.id, id)).limit(1))[0] ?? null;
+	}
+	/** The open request on a document, if there is one. */
+	async pendingFor(contentId) {
+		return (await this.db.select().from(contentApprovals).where(and(eq(contentApprovals.contentId, contentId), eq(contentApprovals.status, "pending"))).orderBy(desc(contentApprovals.requestedAt)).limit(1))[0] ?? null;
+	}
+	/** The most recent request on a document, whatever became of it. */
+	async latestFor(contentId) {
+		return (await this.db.select().from(contentApprovals).where(eq(contentApprovals.contentId, contentId)).orderBy(desc(contentApprovals.requestedAt)).limit(1))[0] ?? null;
+	}
+	historyFor(contentId, limit = 20) {
+		return this.db.select().from(contentApprovals).where(eq(contentApprovals.contentId, contentId)).orderBy(desc(contentApprovals.requestedAt)).limit(limit);
+	}
+	/**
+	* Every open request in a space, oldest first, with the document beside it. Narrowed
+	* to `typeIds` when the reader may only publish some types; `null` means every type.
+	*/
+	async pendingInSpace(spaceId, typeIds = null) {
+		if (typeIds && typeIds.length === 0) return [];
+		const conditions = [eq(contentApprovals.spaceId, spaceId), eq(contentApprovals.status, "pending")];
+		if (typeIds) conditions.push(inArray(contentApprovals.typeId, typeIds));
+		return (await this.db.select({
+			approval: contentApprovals,
+			content: {
+				id: contents.id,
+				title: contents.title,
+				locale: contents.locale,
+				typeId: contents.typeId,
+				updatedAt: contents.updatedAt
+			}
+		}).from(contentApprovals).innerJoin(contents, eq(contents.id, contentApprovals.contentId)).where(and(...conditions)).orderBy(contentApprovals.requestedAt)).map((row) => ({
+			...row.approval,
+			content: row.content
+		}));
+	}
+	async request(data) {
+		const [row] = await this.db.insert(contentApprovals).values({
+			spaceId: data.spaceId,
+			contentId: data.contentId,
+			typeId: data.typeId,
+			requestedBy: data.requestedBy,
+			requestedByLabel: data.requestedByLabel,
+			requestNote: data.requestNote ?? null,
+			contentVersion: data.contentVersion ?? null
+		}).returning();
+		if (!row) throw new ManabloxError("content.approval.create.failed");
+		return row;
+	}
+	async decide(id, data) {
+		const [row] = await this.db.update(contentApprovals).set({
+			status: data.status,
+			decidedBy: data.decidedBy,
+			decidedByLabel: data.decidedByLabel,
+			decisionNote: data.decisionNote ?? null,
+			decidedAt: /* @__PURE__ */ new Date()
+		}).where(eq(contentApprovals.id, id)).returning();
+		if (!row) throw ManabloxError.notFound("content.approval.notPending", { id });
+		return row;
+	}
+};
+//#endregion
 //#region src/repositories/content-type.ts
 /**
 * Persistence for *runtime-defined* content types only. Code-defined types come from
@@ -841,6 +1129,7 @@ var ContentTypeRepository = class {
 			isPublishable: definition.isPublishable,
 			isVisibleInTree: definition.isVisibleInTree,
 			canBeVisibleInMenu: definition.canBeVisibleInMenu,
+			requiresApproval: definition.requiresApproval,
 			fields: definition.fields
 		}).returning();
 		if (!row) throw new ManabloxError("contentType.create.failed");
@@ -869,6 +1158,7 @@ var ContentTypeRepository = class {
 			isPublishable: definition.isPublishable,
 			isVisibleInTree: definition.isVisibleInTree,
 			canBeVisibleInMenu: definition.canBeVisibleInMenu,
+			requiresApproval: definition.requiresApproval,
 			fields: definition.fields,
 			updatedAt: /* @__PURE__ */ new Date()
 		}).where(eq(contentTypes.id, id)).returning();
@@ -892,6 +1182,7 @@ function toDefinition(row) {
 		isPublishable: row.isPublishable,
 		isVisibleInTree: row.isVisibleInTree,
 		canBeVisibleInMenu: row.canBeVisibleInMenu,
+		requiresApproval: row.requiresApproval,
 		fields: row.fields,
 		source: "runtime"
 	};
@@ -1035,6 +1326,75 @@ function buildTree(rows) {
 	return roots;
 }
 //#endregion
+//#region src/repositories/notification.ts
+/**
+* One person's inbox. Every method is scoped to a `userId`, so a row id from another
+* account is inert: there is no way to read or change what is not yours.
+*/
+var NotificationRepository = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	/** Inserts one row per recipient in one statement; an empty list writes nothing. */
+	async insertMany(rows) {
+		if (rows.length === 0) return [];
+		return this.db.insert(notifications).values(rows.map((row) => ({
+			userId: row.userId,
+			spaceId: row.spaceId ?? null,
+			kind: row.kind,
+			title: row.title,
+			body: row.body ?? "",
+			url: row.url ?? null,
+			targetKind: row.targetKind ?? null,
+			targetId: row.targetId ?? null,
+			actorId: row.actorId ?? null,
+			actorLabel: row.actorLabel ?? null,
+			meta: row.meta ?? null
+		}))).returning();
+	}
+	list(userId, filter = {}, pagination = {
+		limit: 25,
+		offset: 0
+	}) {
+		const conditions = [eq(notifications.userId, userId)];
+		if (filter.unreadOnly) conditions.push(isNull(notifications.readAt));
+		if (filter.kinds?.length) conditions.push(inArray(notifications.kind, filter.kinds));
+		if (filter.spaceId === null) conditions.push(isNull(notifications.spaceId));
+		else if (filter.spaceId) conditions.push(eq(notifications.spaceId, filter.spaceId));
+		return paginate(this.db, notifications, {
+			where: and(...conditions),
+			orderBy: [desc(notifications.createdAt), desc(notifications.id)],
+			pagination
+		});
+	}
+	async findById(userId, id) {
+		return (await this.db.select().from(notifications).where(and(eq(notifications.userId, userId), eq(notifications.id, id))).limit(1))[0] ?? null;
+	}
+	async countUnread(userId) {
+		return (await this.db.select({ count: sql`count(*)::int` }).from(notifications).where(and(eq(notifications.userId, userId), isNull(notifications.readAt))))[0]?.count ?? 0;
+	}
+	/** Marks the named rows read; rows already read keep their original time. Returns how many changed. */
+	async markRead(userId, ids) {
+		if (ids.length === 0) return 0;
+		return (await this.db.update(notifications).set({ readAt: /* @__PURE__ */ new Date() }).where(and(eq(notifications.userId, userId), inArray(notifications.id, ids), isNull(notifications.readAt))).returning({ id: notifications.id })).length;
+	}
+	async markUnread(userId, ids) {
+		if (ids.length === 0) return 0;
+		return (await this.db.update(notifications).set({ readAt: null }).where(and(eq(notifications.userId, userId), inArray(notifications.id, ids))).returning({ id: notifications.id })).length;
+	}
+	async markAllRead(userId) {
+		return (await this.db.update(notifications).set({ readAt: /* @__PURE__ */ new Date() }).where(and(eq(notifications.userId, userId), isNull(notifications.readAt))).returning({ id: notifications.id })).length;
+	}
+	async delete(userId, ids) {
+		if (ids.length === 0) return 0;
+		return (await this.db.delete(notifications).where(and(eq(notifications.userId, userId), inArray(notifications.id, ids))).returning({ id: notifications.id })).length;
+	}
+	async deleteRead(userId) {
+		return (await this.db.delete(notifications).where(and(eq(notifications.userId, userId), sql`${notifications.readAt} is not null`)).returning({ id: notifications.id })).length;
+	}
+};
+//#endregion
 //#region src/repositories/role.ts
 var RoleRepository = class {
 	db;
@@ -1163,6 +1523,10 @@ var UserRepository = class {
 		if (ids.length === 0) return [];
 		return this.db.select().from(users).where(inArray(users.id, ids));
 	}
+	/** Every account holding an instance role, for a fan-out to the superadmins. */
+	async findByRole(role) {
+		return this.db.select().from(users).where(eq(users.role, role));
+	}
 	async findByEmail(email) {
 		return (await this.db.select().from(users).where(eq(users.email, email)).limit(1))[0] ?? null;
 	}
@@ -1254,6 +1618,18 @@ var UserRepository = class {
 	async countByRole(role) {
 		return (await this.db.select({ count: sql`count(*)::int` }).from(users).where(eq(users.role, role)))[0]?.count ?? 0;
 	}
+	async setNotificationPreferences(id, preferences) {
+		const [row] = await this.db.update(users).set({
+			notificationPreferences: preferences,
+			updatedAt: /* @__PURE__ */ new Date()
+		}).where(eq(users.id, id)).returning();
+		if (!row) throw ManabloxError.notFound("user.notFound", { id });
+		return row;
+	}
+	/** The stored hash of the password credential, or `null` for an account without one. */
+	async passwordHash(userId) {
+		return (await this.db.select({ password: accounts.password }).from(accounts).where(and(eq(accounts.userId, userId), eq(accounts.providerId, CREDENTIAL_PROVIDER), eq(accounts.issuer, CREDENTIAL_ISSUER))).limit(1))[0]?.password ?? null;
+	}
 	async setRole(id, role) {
 		const [row] = await this.db.update(users).set({
 			role,
@@ -1346,6 +1722,22 @@ var WebhookRepository = class {
 	async findById(id) {
 		return (await this.db.select().from(webhooks).where(eq(webhooks.id, id)).limit(1))[0] ?? null;
 	}
+	async listBySpace(spaceId) {
+		return this.db.select().from(webhooks).where(eq(webhooks.spaceId, spaceId)).orderBy(webhooks.name);
+	}
+	async create(data) {
+		const [row] = await this.db.insert(webhooks).values({
+			...data.id ? { id: data.id } : {},
+			spaceId: data.spaceId,
+			name: data.name,
+			url: data.url,
+			secret: data.secret ?? null,
+			events: data.events,
+			enabled: data.enabled ?? true
+		}).returning();
+		if (!row) throw new ManabloxError("webhook.create.failed");
+		return row;
+	}
 	/** The switched-on webhooks of a space, for fanning an event out. */
 	async findEnabled(spaceId) {
 		return this.db.select().from(webhooks).where(and(eq(webhooks.spaceId, spaceId), eq(webhooks.enabled, true)));
@@ -1515,7 +1907,7 @@ var WorkflowRepository = class {
 };
 //#endregion
 //#region src/repositories/index.ts
-function createRepositories(db, registry) {
+function createRepositories(db, registry, options = {}) {
 	return {
 		content: new ContentRepository(db, registry),
 		contentTypes: new ContentTypeRepository(db),
@@ -1526,8 +1918,11 @@ function createRepositories(db, registry) {
 		menus: new MenuRepository(db),
 		roles: new RoleRepository(db),
 		workflows: new WorkflowRepository(db),
-		webhooks: new WebhookRepository(db)
+		webhooks: new WebhookRepository(db),
+		audit: new AuditRepository(db, options.audit),
+		notifications: new NotificationRepository(db),
+		approvals: new ContentApprovalRepository(db)
 	};
 }
 //#endregion
-export { applyBootstrapSql as _, UserRepository as a, ContentTypeRepository as c, AssetUsageRepository as d, AssetRepository as f, createDatabase as g, paginate as h, WebhookRepository as i, ContentRepository as l, buildOrderBy as m, RUNS_KEPT_PER_WORKFLOW as n, SpaceRepository as o, buildContentWhere as p, WorkflowRepository as r, MenuRepository as s, createRepositories as t, buildTree$1 as u };
+export { buildOrderBy as _, UserRepository as a, applyBootstrapSql as b, MenuRepository as c, ContentRepository as d, buildTree$1 as f, buildContentWhere as g, AssetRepository as h, WebhookRepository as i, ContentTypeRepository as l, AssetUsageRepository as m, RUNS_KEPT_PER_WORKFLOW as n, SpaceRepository as o, AuditRepository as p, WorkflowRepository as r, NotificationRepository as s, createRepositories as t, ContentApprovalRepository as u, paginate as v, createDatabase as y };