@headless-lms/core 0.2.0 → 0.3.0

package/dist/discussion/posts.js

@@ -0,0 +1,723 @@
+import { genId } from "../shared/id.js";
+import { ConflictError, ForbiddenError, InvalidInputError, NotFoundError } from "../shared/errors.js";
+import { noopLogger } from "../shared/logger.js";
+import { canModerate, isStaffRole } from "../organizations/roles.js";
+import { discussionEvents } from "./events.js";
+import { authorView } from "./authors.js";
+import "./ports.js";
+//#region src/discussion/posts.ts
+const PUBLISHED_ONLY = ["published"];
+const DUE_BATCH_SIZE = 100;
+const MODERATOR_VISIBLE = [
+	"published",
+	"pending",
+	"removed"
+];
+var PostServiceImpl = class {
+	repo;
+	access;
+	content;
+	authors;
+	profiles;
+	comments;
+	images;
+	fileUrls;
+	uow;
+	logger;
+	constructor(params) {
+		this.repo = params.repo;
+		this.access = params.access;
+		this.content = params.content;
+		this.authors = params.authors;
+		this.profiles = params.profiles;
+		this.comments = params.comments;
+		this.images = params.images;
+		this.fileUrls = params.fileUrls;
+		this.uow = params.uow;
+		this.logger = params.logger ?? noopLogger;
+	}
+	async visibleTitles(orgId, actor, postIds) {
+		const found = await this.repo.findMany(orgId, [...new Set(postIds)]);
+		const communityIds = [...new Set(found.map((post) => post.communityId))];
+		const open = new Set((await Promise.all(communityIds.map((communityId) => this.access.openSpaceIds(orgId, actor, communityId)))).flat());
+		return Object.fromEntries(found.filter((post) => open.has(post.spaceId) && this.canSee(actor, post)).map((post) => [post.id, post.title]));
+	}
+	async create(orgId, actor, input) {
+		const space = await this.requireOpen(orgId, actor, input.spaceId, input.communityId);
+		await this.requireOwnedImage(orgId, actor.id, input.coverAssetId);
+		this.assertTopic(space, input.topicId);
+		const now = /* @__PURE__ */ new Date();
+		const landing = this.initial(input, space, actor, now);
+		const post = {
+			orgId,
+			id: genId("post"),
+			communityId: space.communityId,
+			spaceId: space.id,
+			orgUserId: actor.id,
+			topicId: input.topicId,
+			title: input.title,
+			body: input.body,
+			extra: input.extra,
+			coverAssetId: input.coverAssetId,
+			pinned: false,
+			commentsClosed: null,
+			reactionsEnabled: null,
+			createdAt: now,
+			updatedAt: now,
+			...landing
+		};
+		const saved = await this.uow.run(async ({ posts, outbox }) => {
+			const created = await posts.insert(orgId, post);
+			const events = [discussionEvents.postCreated.make({
+				orgId,
+				data: created,
+				metadata: this.meta(actor, created.status === "pending" ? null : void 0)
+			})];
+			if (created.status === "published") events.push(discussionEvents.postPublished.make({
+				orgId,
+				data: created,
+				metadata: this.meta(actor, null)
+			}));
+			await outbox.append(events);
+			return created;
+		});
+		this.logger.info("post created", {
+			orgId,
+			postId: saved.id,
+			status: saved.status,
+			actorId: actor.id
+		});
+		return this.viewOf(orgId, actor, saved);
+	}
+	async update(orgId, postId, actor, patch) {
+		const { post, space } = await this.loadVisible(orgId, actor, postId);
+		this.assertAuthor(actor, post);
+		if (post.status === "removed") throw new ConflictError("This post was removed");
+		if (patch.topicId !== void 0) this.assertTopic(space, patch.topicId);
+		if (typeof patch.coverAssetId === "string") await this.requireOwnedImage(orgId, actor.id, patch.coverAssetId);
+		if (!this.patchChanges(post, patch)) return this.viewOf(orgId, actor, post);
+		const updated = await this.uow.run(async ({ posts, outbox }) => {
+			const next = await this.mustUpdate(posts, orgId, postId, patch);
+			await outbox.append([discussionEvents.postUpdated.make({
+				orgId,
+				data: next,
+				metadata: this.meta(actor, next.status === "pending" ? post.status : void 0)
+			})]);
+			return next;
+		});
+		this.logger.info("post updated", {
+			orgId,
+			postId,
+			fields: Object.keys(patch),
+			actorId: actor.id
+		});
+		return this.viewOf(orgId, actor, updated);
+	}
+	async submit(orgId, postId, actor) {
+		const { post, space } = await this.loadVisible(orgId, actor, postId);
+		this.assertAuthor(actor, post);
+		if (post.status !== "draft" && post.status !== "scheduled") throw new ConflictError("This post cannot be submitted");
+		this.assertTopic(space, post.topicId);
+		const saved = await this.commitSubmission(orgId, post, space, actor.role, actor, /* @__PURE__ */ new Date());
+		this.logger.info("post submitted", {
+			orgId,
+			postId,
+			status: saved.status,
+			actorId: actor.id
+		});
+		return this.viewOf(orgId, actor, saved);
+	}
+	async schedule(orgId, postId, actor, scheduledAt) {
+		const { post } = await this.loadVisible(orgId, actor, postId);
+		this.assertAuthor(actor, post);
+		if (post.status === "published" || post.status === "removed" || post.status === "pending") throw new ConflictError("This post cannot be scheduled");
+		if (scheduledAt <= /* @__PURE__ */ new Date()) throw new InvalidInputError("A scheduled time must be in the future");
+		const updated = await this.uow.run(async ({ posts, outbox }) => {
+			const next = await this.mustUpdate(posts, orgId, postId, {
+				status: "scheduled",
+				scheduledAt,
+				publishedAt: null,
+				removedBy: null
+			});
+			await outbox.append([discussionEvents.postUpdated.make({
+				orgId,
+				data: next,
+				metadata: this.meta(actor, post.status)
+			})]);
+			return next;
+		});
+		this.logger.info("post scheduled", {
+			orgId,
+			postId,
+			scheduledAt: scheduledAt.toISOString(),
+			actorId: actor.id
+		});
+		return this.viewOf(orgId, actor, updated);
+	}
+	async approve(orgId, postId, actor, communityId) {
+		const { post } = await this.loadVisible(orgId, actor, postId, communityId);
+		if (!this.canModerate(actor)) throw new ForbiddenError("You cannot review this post");
+		if (post.status !== "pending") throw new ConflictError("This post is not awaiting review");
+		const now = /* @__PURE__ */ new Date();
+		const updated = await this.uow.run(async ({ posts, outbox }) => {
+			const next = await this.mustUpdate(posts, orgId, postId, {
+				status: "published",
+				publishedAt: now,
+				scheduledAt: null,
+				removedBy: null
+			});
+			await outbox.append([discussionEvents.postPublished.make({
+				orgId,
+				data: next,
+				metadata: this.meta(actor, post.status)
+			})]);
+			return next;
+		});
+		this.logger.info("post approved", {
+			orgId,
+			postId,
+			actorId: actor.id
+		});
+		return this.viewOf(orgId, actor, updated);
+	}
+	async remove(orgId, postId, actor, communityId) {
+		const { post } = await this.loadVisible(orgId, actor, postId, communityId);
+		if (post.orgUserId !== actor.id && !this.canModerate(actor)) throw new ForbiddenError("You cannot remove this post");
+		if (post.status === "removed") throw new ConflictError("This post was removed");
+		if (post.status !== "published" && post.status !== "pending") throw new ConflictError("This post cannot be removed");
+		const updated = await this.uow.run(async ({ posts, outbox }) => {
+			const next = await this.mustUpdate(posts, orgId, postId, {
+				status: "removed",
+				removedBy: actor.id
+			});
+			if (post.orgUserId !== actor.id) await posts.resolveFlags(orgId, postId, {
+				resolvedAt: /* @__PURE__ */ new Date(),
+				resolvedBy: actor.id,
+				resolution: "removed"
+			});
+			await outbox.append([discussionEvents.postRemoved.make({
+				orgId,
+				data: next,
+				metadata: this.meta(actor, post.status)
+			})]);
+			return next;
+		});
+		this.logger.info("post removed", {
+			orgId,
+			postId,
+			actorId: actor.id
+		});
+		return this.viewOf(orgId, actor, updated);
+	}
+	async restore(orgId, postId, actor, communityId) {
+		const { post, space } = await this.loadVisible(orgId, actor, postId, communityId);
+		if (!this.canModerate(actor)) throw new ForbiddenError("You cannot moderate this post");
+		if (post.status !== "removed") throw new ConflictError("This post was not removed");
+		const now = /* @__PURE__ */ new Date();
+		const role = await this.authors.roleOf(orgId, post.orgUserId);
+		const updated = await this.uow.run(async ({ posts, outbox }) => {
+			const next = await this.mustUpdate(posts, orgId, postId, this.submissionOf(space.settings.requireReview, role, now));
+			const metadata = this.meta(actor, post.status);
+			const event = next.status === "published" ? discussionEvents.postPublished.make({
+				orgId,
+				data: next,
+				metadata
+			}) : discussionEvents.postUpdated.make({
+				orgId,
+				data: next,
+				metadata
+			});
+			await outbox.append([event]);
+			return next;
+		});
+		this.logger.info("post restored", {
+			orgId,
+			postId,
+			status: updated.status,
+			actorId: actor.id
+		});
+		return this.viewOf(orgId, actor, updated);
+	}
+	pin(orgId, postId, actor) {
+		return this.moderate(orgId, postId, actor, { pinned: true }, (post) => post.pinned, "post pinned");
+	}
+	unpin(orgId, postId, actor) {
+		return this.moderate(orgId, postId, actor, { pinned: false }, (post) => !post.pinned, "post unpinned");
+	}
+	closeComments(orgId, postId, actor) {
+		return this.moderate(orgId, postId, actor, { commentsClosed: true }, (post) => post.commentsClosed === true, "post comments closed");
+	}
+	openComments(orgId, postId, actor) {
+		return this.moderate(orgId, postId, actor, { commentsClosed: false }, (post) => post.commentsClosed === false, "post comments opened");
+	}
+	setReactions(orgId, postId, actor, enabled) {
+		return this.moderate(orgId, postId, actor, { reactionsEnabled: enabled }, (post) => post.reactionsEnabled === enabled, "post reactions changed");
+	}
+	async setReaction(orgId, postId, actor, emoji) {
+		const { post, space } = await this.loadVisible(orgId, actor, postId);
+		if (!(post.reactionsEnabled ?? space.settings.reactions)) throw new ForbiddenError("Reactions are off on this post");
+		await this.repo.setReaction(orgId, postId, actor.id, emoji);
+		this.logger.debug("post reaction set", {
+			orgId,
+			postId,
+			orgUserId: actor.id
+		});
+		return (await this.repo.reactionsOf(orgId, [postId], actor.id))[postId] ?? { reactions: {} };
+	}
+	async follow(orgId, postId, actor) {
+		await this.loadVisible(orgId, actor, postId);
+		await this.repo.follow(orgId, postId, actor.id);
+		this.logger.debug("post followed", {
+			orgId,
+			postId,
+			orgUserId: actor.id
+		});
+	}
+	async unfollow(orgId, postId, actor) {
+		await this.loadVisible(orgId, actor, postId);
+		await this.repo.unfollow(orgId, postId, actor.id);
+		this.logger.debug("post unfollowed", {
+			orgId,
+			postId,
+			orgUserId: actor.id
+		});
+	}
+	async bookmark(orgId, postId, actor) {
+		await this.loadVisible(orgId, actor, postId);
+		await this.repo.bookmark(orgId, postId, actor.id);
+		this.logger.debug("post bookmarked", {
+			orgId,
+			postId,
+			orgUserId: actor.id
+		});
+	}
+	async unbookmark(orgId, postId, actor) {
+		await this.loadVisible(orgId, actor, postId);
+		await this.repo.unbookmark(orgId, postId, actor.id);
+		this.logger.debug("post unbookmarked", {
+			orgId,
+			postId,
+			orgUserId: actor.id
+		});
+	}
+	async flag(orgId, postId, actor, reason) {
+		const { post } = await this.loadVisible(orgId, actor, postId);
+		const now = /* @__PURE__ */ new Date();
+		const flag = {
+			orgId,
+			id: genId("postFlag"),
+			postId,
+			orgUserId: actor.id,
+			reason,
+			resolvedAt: null,
+			resolution: null,
+			resolvedBy: null,
+			createdAt: now,
+			updatedAt: now
+		};
+		const saved = await this.uow.run(async ({ posts, outbox }) => {
+			const created = await posts.insertFlag(orgId, flag);
+			if (!created) {
+				const existing = await posts.findFlag(orgId, postId, actor.id);
+				if (!existing) throw new NotFoundError("Flag", postId);
+				return existing;
+			}
+			await outbox.append([discussionEvents.postReported.make({
+				orgId,
+				data: {
+					...created,
+					communityId: post.communityId
+				},
+				metadata: this.meta(actor)
+			})]);
+			return created;
+		});
+		this.logger.info("post flagged", {
+			orgId,
+			postId,
+			flagId: saved.id,
+			actorId: actor.id
+		});
+		return saved;
+	}
+	async resolveFlags(orgId, postId, actor, resolution, communityId) {
+		await this.loadVisible(orgId, actor, postId, communityId);
+		if (!this.canModerate(actor)) throw new ForbiddenError("You cannot work this queue");
+		await this.repo.resolveFlags(orgId, postId, {
+			resolvedAt: /* @__PURE__ */ new Date(),
+			resolvedBy: actor.id,
+			resolution
+		});
+		this.logger.info("post flags resolved", {
+			orgId,
+			postId,
+			resolution,
+			actorId: actor.id
+		});
+	}
+	async spaceFeed(orgId, actor, communityId, spaceId, query) {
+		const space = await this.requireOpen(orgId, actor, spaceId, communityId);
+		if (query.topicId && !space.topics.some((topic) => topic.id === query.topicId)) throw new NotFoundError("Topic", query.topicId);
+		const page = await this.feedPage(orgId, actor, [spaceId], query);
+		this.logger.debug("space feed read", {
+			orgId,
+			spaceId,
+			rows: page.rows.length
+		});
+		return page;
+	}
+	async memberFeed(orgId, actor, communityId, query) {
+		const spaceIds = await this.openSpaceIdsIn(orgId, actor, communityId);
+		const page = await this.feedPage(orgId, actor, spaceIds, query);
+		this.logger.debug("member feed read", {
+			orgId,
+			communityId,
+			spaces: spaceIds.length,
+			rows: page.rows.length
+		});
+		return page;
+	}
+	async openSpaceIdsIn(orgId, actor, communityId) {
+		if (!await this.access.isCommunityMember(orgId, actor, communityId)) throw new NotFoundError("Community", communityId);
+		return this.access.openSpaceIds(orgId, actor, communityId);
+	}
+	async listOwn(orgId, actor, communityId, query) {
+		const spaceIds = await this.openSpaceIdsIn(orgId, actor, communityId);
+		const page = await this.repo.listByAuthor(orgId, actor.id, spaceIds, query);
+		this.logger.debug("own posts read", {
+			orgId,
+			communityId,
+			rows: page.rows.length
+		});
+		return {
+			...page,
+			rows: await this.viewsOf(orgId, actor, page.rows)
+		};
+	}
+	async listBookmarked(orgId, actor, communityId, query) {
+		const spaceIds = await this.openSpaceIdsIn(orgId, actor, communityId);
+		const page = await this.repo.listBookmarked(orgId, actor.id, spaceIds, {
+			...query,
+			visibleStatuses: this.visibleStatuses(actor)
+		});
+		this.logger.debug("bookmarked posts read", {
+			orgId,
+			communityId,
+			rows: page.rows.length
+		});
+		return {
+			...page,
+			rows: await this.viewsOf(orgId, actor, page.rows)
+		};
+	}
+	async coverFile(orgId, actor, postId) {
+		const post = await this.repo.find(orgId, postId);
+		if (!post?.coverAssetId || !this.canSee(actor, post)) return null;
+		const space = await this.content.getSpace(orgId, post.spaceId);
+		if (!space || !await this.access.canOpen(orgId, actor, space)) return null;
+		return this.images.signFile(orgId, post.coverAssetId);
+	}
+	async getPost(orgId, actor, postId) {
+		const { post } = await this.loadVisible(orgId, actor, postId);
+		this.logger.debug("post read", {
+			orgId,
+			postId
+		});
+		return this.viewOf(orgId, actor, post);
+	}
+	async moderationQueue(orgId, actor, communityId, spaceId) {
+		await this.requireOpen(orgId, actor, spaceId, communityId);
+		if (!this.canModerate(actor)) throw new ForbiddenError("You cannot work this queue");
+		const [pending, flags, openCommentFlags] = await Promise.all([
+			this.repo.listPending(orgId, spaceId, 100),
+			this.repo.listOpenFlags(orgId, spaceId, 100),
+			this.comments.listOpenFlagsForSpace(orgId, spaceId, 100)
+		]);
+		this.logger.debug("space queue read", {
+			orgId,
+			spaceId,
+			pending: pending.length,
+			flags: flags.length,
+			commentFlags: openCommentFlags.length
+		});
+		return {
+			pending: await this.viewsOf(orgId, actor, pending),
+			flags,
+			commentFlags: openCommentFlags
+		};
+	}
+	visible(orgId, actor, postId) {
+		return this.loadVisible(orgId, actor, postId);
+	}
+	find(orgId, postId) {
+		return this.repo.find(orgId, postId);
+	}
+	followerIds(orgId, postId) {
+		return this.repo.followerIds(orgId, postId);
+	}
+	hasDue(orgId, now) {
+		return this.repo.hasDue(orgId, now);
+	}
+	async publishDue(orgId, now) {
+		let afterId;
+		let count = 0;
+		let refused = 0;
+		for (;;) {
+			const due = await this.repo.listDue(orgId, now, DUE_BATCH_SIZE, afterId);
+			if (due.length === 0) break;
+			const batch = await this.submitDue(orgId, now, due);
+			count += batch.count;
+			refused += batch.refused;
+			if (due.length < DUE_BATCH_SIZE) break;
+			afterId = due[due.length - 1].id;
+		}
+		if (count > 0) this.logger.info("due posts submitted", {
+			orgId,
+			count,
+			refused
+		});
+		else this.logger.debug("no posts due", { orgId });
+	}
+	async submitDue(orgId, now, due) {
+		const spaces = /* @__PURE__ */ new Map();
+		const roles = /* @__PURE__ */ new Map();
+		const refused = /* @__PURE__ */ new Set();
+		for (const post of due) {
+			if (!spaces.has(post.spaceId)) spaces.set(post.spaceId, await this.content.getSpace(orgId, post.spaceId));
+			if (!roles.has(post.orgUserId)) roles.set(post.orgUserId, await this.authors.roleOf(orgId, post.orgUserId));
+			const space = spaces.get(post.spaceId);
+			const role = roles.get(post.orgUserId) ?? null;
+			if (space && !await this.submittable(orgId, post, space, role)) refused.add(post.id);
+		}
+		return {
+			count: await this.uow.run(async ({ posts, outbox }) => {
+				const events = [];
+				for (const post of due) {
+					const current = await posts.find(orgId, post.id);
+					if (!current || current.status !== "scheduled" || current.scheduledAt === null || current.scheduledAt > now) continue;
+					const space = spaces.get(current.spaceId);
+					if (!space) {
+						this.logger.error("scheduled post has no space", {
+							orgId,
+							postId: current.id,
+							spaceId: current.spaceId
+						});
+						continue;
+					}
+					const next = await posts.update(orgId, current.id, refused.has(current.id) ? {
+						status: "draft",
+						scheduledAt: null,
+						publishedAt: null,
+						removedBy: null
+					} : this.submissionOf(space.settings.requireReview, roles.get(current.orgUserId) ?? null, now));
+					if (!next) continue;
+					const metadata = this.meta(null, current.status);
+					events.push(next.status === "published" ? discussionEvents.postPublished.make({
+						orgId,
+						data: next,
+						metadata
+					}) : discussionEvents.postUpdated.make({
+						orgId,
+						data: next,
+						metadata
+					}));
+				}
+				if (events.length > 0) await outbox.append(events);
+				return events.length;
+			}),
+			refused: refused.size
+		};
+	}
+	async submittable(orgId, post, space, role) {
+		if (role === null || !this.topicFits(space, post.topicId)) return false;
+		return this.access.canOpen(orgId, {
+			id: post.orgUserId,
+			role
+		}, space);
+	}
+	async feedPage(orgId, actor, spaceIds, query) {
+		const page = await this.repo.listPublished(orgId, spaceIds, query);
+		return {
+			...page,
+			rows: await this.viewsOf(orgId, actor, page.rows)
+		};
+	}
+	async viewOf(orgId, actor, post) {
+		const [view] = await this.viewsOf(orgId, actor, [post]);
+		return view;
+	}
+	async viewsOf(orgId, actor, posts) {
+		if (posts.length === 0) return [];
+		const postIds = posts.map((post) => post.id);
+		const [records, reactions, commentCounts, followed, bookmarked] = await Promise.all([
+			this.profiles.authorsOf(orgId, [...new Set(posts.map((post) => post.orgUserId))]),
+			this.repo.reactionsOf(orgId, postIds, actor.id),
+			this.comments.publishedCommentCounts(orgId, postIds),
+			this.repo.followedAmong(orgId, postIds, actor.id),
+			this.repo.bookmarkedAmong(orgId, postIds, actor.id)
+		]);
+		const following = new Set(followed);
+		const saved = new Set(bookmarked);
+		return posts.map((post) => {
+			const record = records[post.orgUserId];
+			if (!record) throw new NotFoundError("Member", post.orgUserId);
+			const counts = reactions[post.id];
+			return {
+				...post,
+				coverUrl: post.coverAssetId ? this.fileUrls.postCover(post.id) : null,
+				author: authorView(orgId, record, this.fileUrls),
+				reactions: counts?.reactions ?? {},
+				viewerReaction: counts?.viewerReaction ?? null,
+				commentCount: commentCounts[post.id] ?? 0,
+				following: following.has(post.id),
+				bookmarked: saved.has(post.id)
+			};
+		});
+	}
+	async commitSubmission(orgId, post, space, role, actor, now) {
+		return this.uow.run(async ({ posts, outbox }) => {
+			const next = await this.mustUpdate(posts, orgId, post.id, this.submissionOf(space.settings.requireReview, role, now));
+			const metadata = this.meta(actor, post.status);
+			const event = next.status === "published" ? discussionEvents.postPublished.make({
+				orgId,
+				data: next,
+				metadata
+			}) : discussionEvents.postUpdated.make({
+				orgId,
+				data: next,
+				metadata
+			});
+			await outbox.append([event]);
+			return next;
+		});
+	}
+	async moderate(orgId, postId, actor, patch, unchanged, log) {
+		const { post } = await this.loadVisible(orgId, actor, postId);
+		if (!this.canModerate(actor)) throw new ForbiddenError("You cannot moderate this post");
+		if (post.status === "removed") throw new ConflictError("This post was removed");
+		if (unchanged(post)) return this.viewOf(orgId, actor, post);
+		const updated = await this.uow.run(async ({ posts, outbox }) => {
+			const next = await this.mustUpdate(posts, orgId, postId, patch);
+			await outbox.append([discussionEvents.postUpdated.make({
+				orgId,
+				data: next,
+				metadata: this.meta(actor, next.status === "pending" ? post.status : void 0)
+			})]);
+			return next;
+		});
+		this.logger.info(log, {
+			orgId,
+			postId,
+			actorId: actor.id
+		});
+		return this.viewOf(orgId, actor, updated);
+	}
+	async mustUpdate(posts, orgId, postId, patch) {
+		const next = await posts.update(orgId, postId, patch);
+		if (!next) throw new NotFoundError("Post", postId);
+		return next;
+	}
+	initial(input, space, actor, now) {
+		if (input.mode === "draft") return {
+			status: "draft",
+			scheduledAt: null,
+			publishedAt: null,
+			removedBy: null
+		};
+		if (input.mode === "schedule") {
+			if (!input.scheduledAt) throw new InvalidInputError("A scheduled post needs a time");
+			if (input.scheduledAt <= now) throw new InvalidInputError("A scheduled time must be in the future");
+			return {
+				status: "scheduled",
+				scheduledAt: input.scheduledAt,
+				publishedAt: null,
+				removedBy: null
+			};
+		}
+		return this.submissionOf(space.settings.requireReview, actor.role, now);
+	}
+	submissionOf(requireReview, role, now) {
+		if (requireReview && !(role && isStaffRole(role))) return {
+			status: "pending",
+			scheduledAt: null,
+			publishedAt: null,
+			removedBy: null
+		};
+		return {
+			status: "published",
+			scheduledAt: null,
+			publishedAt: now,
+			removedBy: null
+		};
+	}
+	async requireOwnedImage(orgId, orgUserId, assetId) {
+		if (assetId === null) return;
+		if (!await this.images.ownsImage(orgId, assetId, orgUserId)) {
+			this.logger.debug("cover refused", {
+				orgId,
+				orgUserId,
+				assetId
+			});
+			throw new NotFoundError("Asset", assetId);
+		}
+	}
+	async openSpace(orgId, actor, spaceId, communityId) {
+		const space = await this.content.getSpace(orgId, spaceId);
+		if (!space || communityId !== void 0 && space.communityId !== communityId) return null;
+		return await this.access.canOpen(orgId, actor, space) ? space : null;
+	}
+	async requireOpen(orgId, actor, spaceId, communityId) {
+		const space = await this.openSpace(orgId, actor, spaceId, communityId);
+		if (!space) throw new NotFoundError("Space", spaceId);
+		return space;
+	}
+	async loadVisible(orgId, actor, postId, communityId) {
+		const post = await this.repo.find(orgId, postId);
+		if (!post || communityId !== void 0 && post.communityId !== communityId) throw new NotFoundError("Post", postId);
+		const space = await this.openSpace(orgId, actor, post.spaceId);
+		if (!space || !this.canSee(actor, post)) throw new NotFoundError("Post", postId);
+		return {
+			post,
+			space
+		};
+	}
+	canSee(actor, post) {
+		return post.orgUserId === actor.id || this.visibleStatuses(actor).includes(post.status);
+	}
+	visibleStatuses(actor) {
+		return this.canModerate(actor) ? MODERATOR_VISIBLE : PUBLISHED_ONLY;
+	}
+	canModerate(actor) {
+		return canModerate(actor.role);
+	}
+	assertAuthor(actor, post) {
+		if (post.orgUserId !== actor.id) throw new ForbiddenError("You can change only your own post");
+	}
+	topicFits(space, topicId) {
+		if (topicId === null) return space.topics.length === 0;
+		return space.topics.some((topic) => topic.id === topicId);
+	}
+	assertTopic(space, topicId) {
+		if (this.topicFits(space, topicId)) return;
+		if (topicId === null) throw new InvalidInputError("This space requires a topic");
+		throw new NotFoundError("Topic", topicId);
+	}
+	patchChanges(post, patch) {
+		return Object.keys(patch).some((key) => {
+			const value = patch[key];
+			if (value === void 0) return false;
+			if (key === "extra") return JSON.stringify(post.extra) !== JSON.stringify(value);
+			return post[key] !== value;
+		});
+	}
+	meta(actor, previousStatus) {
+		return {
+			...actor ? { actorOrgUserId: actor.id } : {},
+			...previousStatus !== void 0 ? { previousStatus } : {}
+		};
+	}
+};
+//#endregion
+export { PostServiceImpl };
+
+//# sourceMappingURL=posts.js.map