@headless-lms/core 0.1.0 → 0.3.0

package/dist/content/service.js

@@ -1,49 +1,71 @@
+import { spaceSettingsDefaults } from "../types/schemas/content.js";
+import { ConflictError, ForbiddenError, InvalidInputError, NotFoundError } from "../shared/errors.js";
 import { noopLogger } from "../shared/logger.js";
 import { contentEvents } from "./events.js";
-import "../shared/settings.js";
-import { ConflictError, NotFoundError } from "../shared/errors.js";
 //#region src/content/service.ts
 /** URL-safe slug derived from a title. Domain rule owned by the service. */
 function slugify(title) {
 	return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
 }
-/** Defaults for keys the stored blob doesn't carry (rows predating a setting). */
-const settingsDefaults = { transcriptDownloads: false };
-function toCourseSettings(stored) {
-	return {
-		...settingsDefaults,
-		...stored
-	};
+function actorMetadata(actor) {
+	return { actorOrgUserId: actor.id };
 }
-var ContentServiceImpl = class {
+function assertConfigurator(actor) {
+	if (actor.role !== "owner" && actor.role !== "admin") throw new ForbiddenError("Only an owner or an admin can configure a community");
+}
+function sameIdSet(current, requested) {
+	if (current.length !== requested.length) return false;
+	const have = new Set(current);
+	return requested.every((id) => have.has(id)) && new Set(requested).size === requested.length;
+}
+var ContentService = class {
 	repo;
 	uow;
-	settings;
+	libraryAssets;
+	files;
+	fileUrls;
 	logger;
 	constructor(params) {
 		this.repo = params.repo;
 		this.uow = params.uow;
-		this.settings = params.settings;
+		this.libraryAssets = params.libraryAssets;
+		this.files = params.files;
+		this.fileUrls = params.fileUrls;
 		this.logger = params.logger ?? noopLogger;
 	}
-	list(orgId, query) {
-		return this.repo.list(orgId, query);
+	withThumbnail(item) {
+		return {
+			...item,
+			thumbnailUrl: item.thumbnailAssetId ? this.fileUrls.thumbnail(item.type, item.id) : null
+		};
 	}
-	async getCourse(orgId, id) {
-		const course = await this.repo.findById(orgId, id);
-		if (!course) return null;
-		const settings = await this.settings.get(orgId, "content", id);
+	pageWithThumbnails(page) {
 		return {
-			...course,
-			settings: {
-				...toCourseSettings(course.settings),
-				...settings
-			}
+			...page,
+			rows: page.rows.map((row) => this.withThumbnail(row))
 		};
 	}
+	async downloadFiles(orgId, links) {
+		const ready = await this.files.readyFiles(orgId, links.map((link) => link.assetId));
+		return links.flatMap((link) => {
+			const file = ready[link.assetId];
+			return file ? [{
+				...link,
+				...file,
+				url: this.fileUrls.downloadFile(link.downloadId, link.assetId)
+			}] : [];
+		});
+	}
+	async listCourses(orgId, query) {
+		return this.pageWithThumbnails(await this.repo.listCourses(orgId, query));
+	}
+	async getCourse(orgId, id) {
+		const course = await this.repo.findCourseById(orgId, id);
+		return course ? this.withThumbnail(course) : null;
+	}
 	async createCourse(orgId, input) {
 		const course = await this.uow.run(async ({ content, outbox }) => {
-			const created = await content.create(orgId, input, slugify(input.title));
+			const created = await content.createCourse(orgId, input, slugify(input.title));
 			await outbox.append([contentEvents.courseCreated.make({
 				orgId,
 				data: created
@@ -55,11 +77,12 @@ var ContentServiceImpl = class {
 			courseId: course.id,
 			title: course.title
 		});
-		return course;
+		return this.withThumbnail(course);
 	}
 	async updateCourse(orgId, id, patch) {
+		await this.assertLibraryAssets(orgId, [patch.thumbnailAssetId], "A course");
 		const course = await this.uow.run(async ({ content, outbox }) => {
-			const updated = await content.update(orgId, id, patch);
+			const updated = await content.updateCourse(orgId, id, patch);
 			if (!updated) {
 				this.logger.warn("course update rejected — not found", {
 					orgId,
@@ -78,31 +101,38 @@ var ContentServiceImpl = class {
 			courseId: id,
 			fields: Object.keys(patch)
 		});
-		return course;
+		return this.withThumbnail(course);
 	}
-	async patchSettings(orgId, id, value) {
-		const course = await this.repo.findById(orgId, id);
-		if (!course) {
-			this.logger.warn("course settings patch rejected — not found", {
+	async patchCourseSettings(orgId, id, value) {
+		const merged = await this.uow.run(async ({ content, outbox }) => {
+			const course = await content.findCourseById(orgId, id);
+			if (!course) {
+				this.logger.warn("course settings patch rejected — not found", {
+					orgId,
+					courseId: id
+				});
+				throw new NotFoundError("Course", id);
+			}
+			const settings = await content.patchCourseSettings(orgId, id, value);
+			await outbox.append([contentEvents.courseUpdated.make({
 				orgId,
-				courseId: id
-			});
-			throw new NotFoundError("Course", id);
-		}
-		const merged = await this.settings.patch(orgId, "content", id, value);
+				data: {
+					...course,
+					settings
+				}
+			})]);
+			return settings;
+		});
 		this.logger.info("course settings patched", {
 			orgId,
 			courseId: id,
 			value
 		});
-		return {
-			...toCourseSettings(course.settings),
-			...merged
-		};
+		return merged;
 	}
-	async deleteCourse(orgId, id) {
+	async deleteCourse(orgId, id, actor) {
 		await this.uow.run(async ({ content, outbox }) => {
-			const course = await content.findById(orgId, id);
+			const course = await content.findCourseById(orgId, id);
 			if (!course) {
 				this.logger.warn("course delete rejected — not found", {
 					orgId,
@@ -110,11 +140,12 @@ var ContentServiceImpl = class {
 				});
 				throw new NotFoundError("Course", id);
 			}
-			if (!await content.delete(orgId, id)) throw new NotFoundError("Course", id);
+			const linked = await content.spacesLinkingContent(orgId, id);
+			if (!await content.deleteCourse(orgId, id)) throw new NotFoundError("Course", id);
 			await outbox.append([contentEvents.courseDeleted.make({
 				orgId,
 				data: course
-			})]);
+			}), ...await this.spaceUpdates(content, orgId, linked, actor)]);
 		});
 		this.logger.info("course deleted", {
 			orgId,
@@ -122,11 +153,21 @@ var ContentServiceImpl = class {
 		});
 	}
 	listCourseModules(orgId, courseId) {
-		return this.repo.listForCourse(orgId, courseId);
+		return this.repo.listCourseModules(orgId, courseId);
 	}
 	listCourseActivities(orgId, courseId) {
 		return this.repo.listActivitiesForCourse(orgId, courseId);
 	}
+	async listCourseActivityViews(orgId, courseId) {
+		const [activities, links] = await Promise.all([this.repo.listActivitiesForCourse(orgId, courseId), this.repo.listActivityAssetsForCourse(orgId, courseId)]);
+		return activities.map((activity) => ({
+			...activity,
+			assetUrls: Object.fromEntries(links.filter((link) => link.activityId === activity.id).map((link) => [link.assetId, this.fileUrls.activityAsset(activity.id, link.assetId)]))
+		}));
+	}
+	listCourseActivityAssets(orgId, courseId) {
+		return this.repo.listActivityAssetsForCourse(orgId, courseId);
+	}
 	getActivity(orgId, activityId) {
 		return this.repo.findActivity(orgId, activityId);
 	}
@@ -242,7 +283,21 @@ var ContentServiceImpl = class {
 		});
 		return modules;
 	}
+	async assertLibraryAssets(orgId, assetIds, user = "An activity") {
+		const ids = assetIds.filter((id) => typeof id === "string");
+		if (ids.length === 0) return;
+		const library = new Set(await this.libraryAssets.libraryAssetsAmong(orgId, ids));
+		const refused = ids.filter((id) => !library.has(id));
+		if (refused.length > 0) {
+			this.logger.warn("library assets refused", {
+				orgId,
+				assetIds: refused
+			});
+			throw new ConflictError(`${user} can only use ready files from the media library. Not available: ${refused.join(", ")}`);
+		}
+	}
 	async saveActivity(orgId, courseId, moduleId, input, activityId) {
+		await this.assertLibraryAssets(orgId, input.assetIds ?? []);
 		const { modules, activity } = await this.uow.run(async ({ content, outbox }) => {
 			if (activityId) {
 				const existing = await content.findActivity(orgId, activityId);
@@ -314,11 +369,12 @@ var ContentServiceImpl = class {
 		});
 		return modules;
 	}
-	listDownloads(orgId, query) {
-		return this.repo.listDownloads(orgId, query);
+	async listDownloads(orgId, query) {
+		return this.pageWithThumbnails(await this.repo.listDownloads(orgId, query));
 	}
-	getDownload(orgId, id) {
-		return this.repo.getDownload(orgId, id);
+	async getDownload(orgId, id) {
+		const download = await this.repo.getDownload(orgId, id);
+		return download ? this.withThumbnail(download) : null;
 	}
 	async createDownload(orgId, input) {
 		const download = await this.uow.run(async ({ content, outbox }) => {
@@ -334,9 +390,10 @@ var ContentServiceImpl = class {
 			downloadId: download.id,
 			title: download.title
 		});
-		return download;
+		return this.withThumbnail(download);
 	}
 	async updateDownload(orgId, id, patch) {
+		await this.assertLibraryAssets(orgId, [patch.thumbnailAssetId], "A download");
 		const download = await this.uow.run(async ({ content, outbox }) => {
 			const updated = await content.updateDownload(orgId, id, patch);
 			if (!updated) {
@@ -357,9 +414,9 @@ var ContentServiceImpl = class {
 			downloadId: id,
 			fields: Object.keys(patch)
 		});
-		return download;
+		return this.withThumbnail(download);
 	}
-	async removeDownload(orgId, id) {
+	async removeDownload(orgId, id, actor) {
 		await this.uow.run(async ({ content, outbox }) => {
 			const download = await content.getDownload(orgId, id);
 			if (!download) {
@@ -369,21 +426,23 @@ var ContentServiceImpl = class {
 				});
 				throw new NotFoundError("Download", id);
 			}
+			const linked = await content.spacesLinkingContent(orgId, id);
 			if (!await content.deleteDownload(orgId, id)) throw new NotFoundError("Download", id);
 			await outbox.append([contentEvents.downloadDeleted.make({
 				orgId,
 				data: download
-			})]);
+			}), ...await this.spaceUpdates(content, orgId, linked, actor)]);
 		});
 		this.logger.info("download deleted", {
 			orgId,
 			downloadId: id
 		});
 	}
-	listDownloadAssets(orgId, downloadId) {
-		return this.repo.listDownloadAssets(orgId, downloadId);
+	async listDownloadAssets(orgId, downloadId) {
+		return this.downloadFiles(orgId, await this.repo.listDownloadAssets(orgId, downloadId));
 	}
 	async addDownloadAsset(orgId, downloadId, input) {
+		await this.assertLibraryAssets(orgId, [input.assetId], "A download");
 		const assets = await this.uow.run(async ({ content, outbox }) => {
 			const assets = await content.addDownloadAsset(orgId, downloadId, input);
 			await outbox.append([contentEvents.downloadAssetAdded.make({
@@ -400,7 +459,7 @@ var ContentServiceImpl = class {
 			downloadId,
 			assetId: input.assetId
 		});
-		return assets;
+		return this.downloadFiles(orgId, assets);
 	}
 	async removeDownloadAsset(orgId, downloadId, assetId) {
 		const assets = await this.uow.run(async ({ content, outbox }) => {
@@ -419,7 +478,7 @@ var ContentServiceImpl = class {
 			downloadId,
 			assetId
 		});
-		return assets;
+		return this.downloadFiles(orgId, assets);
 	}
 	async renameDownloadAsset(orgId, downloadId, assetId, displayName) {
 		const assets = await this.uow.run(async ({ content, outbox }) => {
@@ -438,7 +497,7 @@ var ContentServiceImpl = class {
 			downloadId,
 			assetId
 		});
-		return assets;
+		return this.downloadFiles(orgId, assets);
 	}
 	/** The caller must send the COMPLETE ordered set — a partial list would
 	*  silently unlink whatever it omitted. */
@@ -470,10 +529,538 @@ var ContentServiceImpl = class {
 			orgId,
 			downloadId
 		});
-		return assets;
+		return this.downloadFiles(orgId, assets);
+	}
+	listBundles(orgId, query) {
+		return this.repo.listBundles(orgId, query);
+	}
+	getBundle(orgId, id) {
+		return this.repo.findBundleById(orgId, id);
+	}
+	async createBundle(orgId, input) {
+		const { bundle, items } = await this.uow.run(async ({ content, outbox }) => {
+			const created = await content.createBundle(orgId, input);
+			const initial = input.contentIds?.length ? await content.listBundleItems(orgId, created.id) : [];
+			await outbox.append([contentEvents.bundleCreated.make({
+				orgId,
+				data: created
+			}), ...initial.length > 0 ? [contentEvents.bundleItemAdded.make({
+				orgId,
+				data: {
+					bundleId: created.id,
+					items: initial
+				}
+			})] : []]);
+			return {
+				bundle: created,
+				items: initial
+			};
+		});
+		this.logger.info("bundle created", {
+			orgId,
+			bundleId: bundle.id,
+			name: bundle.name,
+			itemCount: items.length
+		});
+		return bundle;
+	}
+	async updateBundle(orgId, id, patch) {
+		const bundle = await this.uow.run(async ({ content, outbox }) => {
+			const updated = await content.updateBundle(orgId, id, patch);
+			if (!updated) {
+				this.logger.warn("bundle update rejected — not found", {
+					orgId,
+					bundleId: id
+				});
+				throw new NotFoundError("Bundle", id);
+			}
+			await outbox.append([contentEvents.bundleUpdated.make({
+				orgId,
+				data: updated
+			})]);
+			return updated;
+		});
+		this.logger.info("bundle updated", {
+			orgId,
+			bundleId: id,
+			fields: Object.keys(patch)
+		});
+		return bundle;
+	}
+	async deleteBundle(orgId, id) {
+		await this.uow.run(async ({ content, outbox }) => {
+			const bundle = await content.findBundleById(orgId, id);
+			if (!bundle) {
+				this.logger.warn("bundle delete rejected — not found", {
+					orgId,
+					bundleId: id
+				});
+				throw new NotFoundError("Bundle", id);
+			}
+			if (!await content.deleteBundle(orgId, id)) throw new NotFoundError("Bundle", id);
+			await outbox.append([contentEvents.bundleDeleted.make({
+				orgId,
+				data: bundle
+			})]);
+		});
+		this.logger.info("bundle deleted", {
+			orgId,
+			bundleId: id
+		});
+	}
+	listBundleItems(orgId, bundleId) {
+		return this.repo.listBundleItems(orgId, bundleId);
+	}
+	async addBundleItem(orgId, bundleId, contentId) {
+		const items = await this.uow.run(async ({ content, outbox }) => {
+			const all = await content.addBundleItem(orgId, bundleId, contentId);
+			await outbox.append([contentEvents.bundleItemAdded.make({
+				orgId,
+				data: {
+					bundleId,
+					items: all
+				}
+			})]);
+			return all;
+		});
+		this.logger.info("bundle item added", {
+			orgId,
+			bundleId,
+			contentId
+		});
+		return items;
+	}
+	async removeBundleItem(orgId, bundleId, contentId) {
+		const items = await this.uow.run(async ({ content, outbox }) => {
+			const all = await content.removeBundleItem(orgId, bundleId, contentId);
+			await outbox.append([contentEvents.bundleItemRemoved.make({
+				orgId,
+				data: {
+					bundleId,
+					items: all
+				}
+			})]);
+			return all;
+		});
+		this.logger.info("bundle item removed", {
+			orgId,
+			bundleId,
+			contentId
+		});
+		return items;
+	}
+	async spaceUpdates(content, orgId, spaceIds, actor) {
+		const events = [];
+		for (const spaceId of spaceIds) {
+			const space = await content.findSpace(orgId, spaceId);
+			if (space) events.push(contentEvents.spaceUpdated.make({
+				orgId,
+				data: space,
+				metadata: actorMetadata(actor)
+			}));
+		}
+		return events;
+	}
+	resolvedSpace(input, current) {
+		const accessRule = input.accessRule ?? current?.accessRule ?? "all_members";
+		let capacity = input.capacity !== void 0 ? input.capacity : current?.capacity ?? null;
+		if (accessRule === "all_members") {
+			if (input.capacity != null) throw new InvalidInputError("An all-members space has no capacity");
+			capacity = null;
+		}
+		const settings = {
+			...current?.settings ?? spaceSettingsDefaults,
+			...input.settings
+		};
+		return {
+			accessRule,
+			capacity,
+			settings
+		};
+	}
+	async listCommunities(orgId, query) {
+		return this.pageWithThumbnails(await this.repo.listCommunities(orgId, query));
+	}
+	async getCommunity(orgId, id) {
+		const community = await this.repo.findCommunityById(orgId, id);
+		return community ? this.withThumbnail(community) : null;
+	}
+	listPublishedCommunityIds(orgId) {
+		return this.repo.listPublishedCommunityIds(orgId);
+	}
+	listCommunitiesById(orgId, ids) {
+		return ids.length ? this.repo.findCommunitiesByIds(orgId, ids) : Promise.resolve([]);
+	}
+	getSpace(orgId, spaceId) {
+		return this.repo.findSpace(orgId, spaceId);
+	}
+	async getCommunitySpace(orgId, communityId, spaceId) {
+		const space = await this.repo.findSpace(orgId, spaceId);
+		return space?.communityId === communityId ? space : null;
+	}
+	async listSpaces(orgId, communityId) {
+		if (!await this.getCommunity(orgId, communityId)) throw new NotFoundError("Community", communityId);
+		return this.repo.listSpaces(orgId, communityId);
+	}
+	async getDmSettings(orgId, communityId) {
+		return (await this.repo.findCommunityById(orgId, communityId))?.settings.dm ?? null;
+	}
+	async createCommunity(orgId, input, actor) {
+		assertConfigurator(actor);
+		const community = await this.uow.run(async ({ content, outbox }) => {
+			const created = await content.createCommunity(orgId, input, slugify(input.title));
+			await outbox.append([contentEvents.communityCreated.make({
+				orgId,
+				data: created,
+				metadata: actorMetadata(actor)
+			})]);
+			return created;
+		});
+		this.logger.info("community created", {
+			orgId,
+			communityId: community.id,
+			actorId: actor.id
+		});
+		return this.withThumbnail(community);
+	}
+	async updateCommunity(orgId, id, patch, actor) {
+		assertConfigurator(actor);
+		await this.assertLibraryAssets(orgId, [patch.thumbnailAssetId], "A community");
+		const community = await this.uow.run(async ({ content, outbox }) => {
+			const updated = await content.updateCommunity(orgId, id, patch);
+			if (!updated) {
+				this.logger.warn("community update rejected — not found", {
+					orgId,
+					communityId: id,
+					actorId: actor.id
+				});
+				throw new NotFoundError("Community", id);
+			}
+			await outbox.append([contentEvents.communityUpdated.make({
+				orgId,
+				data: updated,
+				metadata: actorMetadata(actor)
+			})]);
+			return updated;
+		});
+		this.logger.info("community updated", {
+			orgId,
+			communityId: id,
+			actorId: actor.id
+		});
+		return this.withThumbnail(community);
+	}
+	publishCommunity(orgId, id, actor) {
+		return this.updateCommunity(orgId, id, { status: "published" }, actor);
+	}
+	unpublishCommunity(orgId, id, actor) {
+		return this.updateCommunity(orgId, id, { status: "draft" }, actor);
+	}
+	async deleteCommunity(orgId, id, actor) {
+		assertConfigurator(actor);
+		await this.uow.run(async ({ content, outbox }) => {
+			const community = await content.findCommunityById(orgId, id);
+			if (!community) {
+				this.logger.warn("community delete rejected — not found", {
+					orgId,
+					communityId: id,
+					actorId: actor.id
+				});
+				throw new NotFoundError("Community", id);
+			}
+			const linked = await content.spacesLinkingContent(orgId, id);
+			if (!await content.deleteCommunity(orgId, id)) throw new NotFoundError("Community", id);
+			await content.deleteCommunitySettings(orgId, id);
+			await outbox.append([contentEvents.communityDeleted.make({
+				orgId,
+				data: community,
+				metadata: actorMetadata(actor)
+			}), ...await this.spaceUpdates(content, orgId, linked, actor)]);
+		});
+		this.logger.info("community deleted", {
+			orgId,
+			communityId: id,
+			actorId: actor.id
+		});
+	}
+	async patchDmSettings(orgId, id, patch, actor) {
+		assertConfigurator(actor);
+		const community = await this.uow.run(async ({ content, outbox }) => {
+			const updated = await content.patchDmSettings(orgId, id, patch);
+			if (!updated) {
+				this.logger.warn("community dm settings patch rejected — not found", {
+					orgId,
+					communityId: id,
+					actorId: actor.id
+				});
+				throw new NotFoundError("Community", id);
+			}
+			await outbox.append([contentEvents.communityUpdated.make({
+				orgId,
+				data: updated,
+				metadata: actorMetadata(actor)
+			})]);
+			return updated;
+		});
+		this.logger.info("community dm settings patched", {
+			orgId,
+			communityId: id,
+			actorId: actor.id
+		});
+		return this.withThumbnail(community);
+	}
+	async createSpace(orgId, communityId, input, actor) {
+		assertConfigurator(actor);
+		const resolved = this.resolvedSpace(input);
+		const space = await this.uow.run(async ({ content, outbox }) => {
+			if (!await content.findCommunityById(orgId, communityId)) {
+				this.logger.warn("space create rejected — community not found", {
+					orgId,
+					communityId,
+					actorId: actor.id
+				});
+				throw new NotFoundError("Community", communityId);
+			}
+			const created = await content.createSpace(orgId, communityId, {
+				...input,
+				accessRule: resolved.accessRule,
+				capacity: resolved.capacity,
+				settings: resolved.settings
+			});
+			await outbox.append([contentEvents.spaceCreated.make({
+				orgId,
+				data: created,
+				metadata: actorMetadata(actor)
+			})]);
+			return created;
+		});
+		this.logger.info("space created", {
+			orgId,
+			communityId,
+			spaceId: space.id,
+			actorId: actor.id
+		});
+		return space;
+	}
+	async updateSpace(orgId, communityId, spaceId, patch, actor) {
+		assertConfigurator(actor);
+		const space = await this.uow.run(async ({ content, outbox }) => {
+			const current = await content.findSpace(orgId, spaceId);
+			if (!current || current.communityId !== communityId) {
+				this.logger.warn("space update rejected — not found", {
+					orgId,
+					communityId,
+					spaceId,
+					actorId: actor.id
+				});
+				throw new NotFoundError("Space", spaceId);
+			}
+			const resolved = this.resolvedSpace(patch, current);
+			const updated = await content.updateSpace(orgId, communityId, spaceId, {
+				...patch,
+				accessRule: resolved.accessRule,
+				capacity: resolved.capacity,
+				settings: resolved.settings
+			});
+			if (!updated) throw new NotFoundError("Space", spaceId);
+			await outbox.append([contentEvents.spaceUpdated.make({
+				orgId,
+				data: updated,
+				metadata: actorMetadata(actor)
+			})]);
+			return updated;
+		});
+		this.logger.info("space updated", {
+			orgId,
+			communityId,
+			spaceId,
+			actorId: actor.id
+		});
+		return space;
+	}
+	async deleteSpace(orgId, communityId, spaceId, actor) {
+		assertConfigurator(actor);
+		await this.uow.run(async ({ content, outbox }) => {
+			const space = await content.findSpace(orgId, spaceId);
+			if (!space || space.communityId !== communityId) {
+				this.logger.warn("space delete rejected — not found", {
+					orgId,
+					communityId,
+					spaceId,
+					actorId: actor.id
+				});
+				throw new NotFoundError("Space", spaceId);
+			}
+			if (!await content.deleteSpace(orgId, communityId, spaceId)) throw new NotFoundError("Space", spaceId);
+			await outbox.append([contentEvents.spaceDeleted.make({
+				orgId,
+				data: space,
+				metadata: actorMetadata(actor)
+			})]);
+		});
+		this.logger.info("space deleted", {
+			orgId,
+			communityId,
+			spaceId,
+			actorId: actor.id
+		});
+	}
+	async reorderSpaces(orgId, communityId, orderedIds, actor) {
+		assertConfigurator(actor);
+		const spaces = await this.uow.run(async ({ content, outbox }) => {
+			if (!await content.findCommunityById(orgId, communityId)) {
+				this.logger.warn("spaces reorder rejected — community not found", {
+					orgId,
+					communityId,
+					actorId: actor.id
+				});
+				throw new NotFoundError("Community", communityId);
+			}
+			if (!sameIdSet((await content.listSpaces(orgId, communityId)).map((space) => space.id), orderedIds)) throw new ConflictError("Ordered space ids do not match the community's spaces");
+			const reordered = await content.reorderSpaces(orgId, communityId, orderedIds);
+			await outbox.append([contentEvents.spacesReordered.make({
+				orgId,
+				data: reordered,
+				metadata: actorMetadata(actor)
+			})]);
+			return reordered;
+		});
+		this.logger.info("spaces reordered", {
+			orgId,
+			communityId,
+			actorId: actor.id
+		});
+		return spaces;
+	}
+	async setSpaceTopics(orgId, communityId, spaceId, input, actor) {
+		assertConfigurator(actor);
+		const names = input.topics.map((topic) => topic.name);
+		if (new Set(names).size !== names.length) throw new InvalidInputError("A space topic name is already used");
+		const space = await this.uow.run(async ({ content, outbox }) => {
+			const locked = await content.lockSpace(orgId, spaceId);
+			if (!locked || locked.communityId !== communityId) {
+				this.logger.warn("space topics rejected — space not found", {
+					orgId,
+					communityId,
+					spaceId,
+					actorId: actor.id
+				});
+				throw new NotFoundError("Space", spaceId);
+			}
+			const current = await content.findSpace(orgId, spaceId);
+			if (!current) throw new NotFoundError("Space", spaceId);
+			const kept = new Set(input.topics.flatMap((topic) => topic.id ? [topic.id] : []));
+			const removed = current.topics.filter((topic) => !kept.has(topic.id)).map((topic) => topic.id);
+			if (removed.length > 0 && (await content.topicsInUse(orgId, spaceId, removed)).length > 0) throw new ConflictError("A topic used by a post cannot be removed");
+			const updated = await content.setSpaceTopics(orgId, spaceId, input);
+			await outbox.append([contentEvents.spaceUpdated.make({
+				orgId,
+				data: updated,
+				metadata: actorMetadata(actor)
+			})]);
+			return updated;
+		});
+		this.logger.info("space topics set", {
+			orgId,
+			communityId,
+			spaceId,
+			actorId: actor.id
+		});
+		return space;
+	}
+	async addSpaceLink(orgId, communityId, spaceId, contentId, actor) {
+		assertConfigurator(actor);
+		const space = await this.uow.run(async ({ content, outbox }) => {
+			const current = await content.findSpace(orgId, spaceId);
+			if (!current || current.communityId !== communityId) {
+				this.logger.warn("space link add rejected — space not found", {
+					orgId,
+					communityId,
+					spaceId,
+					actorId: actor.id
+				});
+				throw new NotFoundError("Space", spaceId);
+			}
+			if (current.links.some((link) => link.contentId === contentId)) throw new ConflictError("This space already links to that content");
+			const updated = await content.addSpaceLink(orgId, spaceId, contentId);
+			await outbox.append([contentEvents.spaceUpdated.make({
+				orgId,
+				data: updated,
+				metadata: actorMetadata(actor)
+			})]);
+			return updated;
+		});
+		this.logger.info("space link added", {
+			orgId,
+			communityId,
+			spaceId,
+			contentId,
+			actorId: actor.id
+		});
+		return space;
+	}
+	async removeSpaceLink(orgId, communityId, spaceId, linkId, actor) {
+		assertConfigurator(actor);
+		const space = await this.uow.run(async ({ content, outbox }) => {
+			const current = await content.findSpace(orgId, spaceId);
+			if (!current || current.communityId !== communityId) {
+				this.logger.warn("space link remove rejected — space not found", {
+					orgId,
+					communityId,
+					spaceId,
+					actorId: actor.id
+				});
+				throw new NotFoundError("Space", spaceId);
+			}
+			const updated = await content.removeSpaceLink(orgId, spaceId, linkId);
+			await outbox.append([contentEvents.spaceUpdated.make({
+				orgId,
+				data: updated,
+				metadata: actorMetadata(actor)
+			})]);
+			return updated;
+		});
+		this.logger.info("space link removed", {
+			orgId,
+			communityId,
+			spaceId,
+			linkId,
+			actorId: actor.id
+		});
+		return space;
+	}
+	async reorderSpaceLinks(orgId, communityId, spaceId, orderedIds, actor) {
+		assertConfigurator(actor);
+		const space = await this.uow.run(async ({ content, outbox }) => {
+			const current = await content.findSpace(orgId, spaceId);
+			if (!current || current.communityId !== communityId) {
+				this.logger.warn("space links reorder rejected — space not found", {
+					orgId,
+					communityId,
+					spaceId,
+					actorId: actor.id
+				});
+				throw new NotFoundError("Space", spaceId);
+			}
+			if (!sameIdSet(current.links.map((link) => link.id), orderedIds)) throw new ConflictError("Ordered link ids do not match the space's links");
+			const updated = await content.reorderSpaceLinks(orgId, spaceId, orderedIds);
+			await outbox.append([contentEvents.spaceUpdated.make({
+				orgId,
+				data: updated,
+				metadata: actorMetadata(actor)
+			})]);
+			return updated;
+		});
+		this.logger.info("space links reordered", {
+			orgId,
+			communityId,
+			spaceId,
+			actorId: actor.id
+		});
+		return space;
 	}
 };
 //#endregion
-export { ContentServiceImpl };
+export { ContentService };
 
 //# sourceMappingURL=service.js.map