@headless-lms/core 0.3.0 → 0.4.0

package/dist/discussion/posts.js

@@ -1,18 +1,26 @@
 import { genId } from "../shared/id.js";
-import { ConflictError, ForbiddenError, InvalidInputError, NotFoundError } from "../shared/errors.js";
+import { ConflictError, ForbiddenError, InvalidInputError, NotFoundError, UnavailableError } 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 { keepAllowed, mentionTokens, mentionViews } from "./mentions.js";
+import { POST_PUBLISH_JOB } from "./jobs.js";
+import { activeSubscription } from "./subscriptions.js";
 import "./ports.js";
 //#region src/discussion/posts.ts
 const PUBLISHED_ONLY = ["published"];
-const DUE_BATCH_SIZE = 100;
 const MODERATOR_VISIBLE = [
 	"published",
 	"pending",
 	"removed"
 ];
+const DRAFT = {
+	status: "draft",
+	scheduledAt: null,
+	publishedAt: null,
+	removedBy: null
+};
 var PostServiceImpl = class {
 	repo;
 	access;
@@ -20,9 +28,12 @@ var PostServiceImpl = class {
 	authors;
 	profiles;
 	comments;
+	subscriptions;
+	mentions;
 	images;
 	fileUrls;
 	uow;
+	scheduler;
 	logger;
 	constructor(params) {
 		this.repo = params.repo;
@@ -31,9 +42,12 @@ var PostServiceImpl = class {
 		this.authors = params.authors;
 		this.profiles = params.profiles;
 		this.comments = params.comments;
+		this.subscriptions = params.subscriptions;
+		this.mentions = params.mentions;
 		this.images = params.images;
 		this.fileUrls = params.fileUrls;
 		this.uow = params.uow;
+		this.scheduler = params.scheduler;
 		this.logger = params.logger ?? noopLogger;
 	}
 	async visibleTitles(orgId, actor, postIds) {
@@ -42,6 +56,9 @@ var PostServiceImpl = class {
 		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]));
 	}
+	publishedBetween(orgId, communityId, from, to) {
+		return this.repo.publishedBetween(orgId, communityId, from, to);
+	}
 	async create(orgId, actor, input) {
 		const space = await this.requireOpen(orgId, actor, input.spaceId, input.communityId);
 		await this.requireOwnedImage(orgId, actor.id, input.coverAssetId);
@@ -66,18 +83,16 @@ var PostServiceImpl = class {
 			updatedAt: now,
 			...landing
 		};
-		const saved = await this.uow.run(async ({ posts, outbox }) => {
+		const mentioned = await this.mentionable(orgId, space.id, post.title, post.body);
+		const saved = await this.uow.run(async ({ posts, mentions, outbox }) => {
 			const created = await posts.insert(orgId, post);
+			await mentions.sync(orgId, "post", created.id, mentioned, now);
 			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)
-			}));
+			if (created.status === "published") events.push(this.published(orgId, created, this.meta(actor, null), mentioned));
 			await outbox.append(events);
 			return created;
 		});
@@ -87,6 +102,7 @@ var PostServiceImpl = class {
 			status: saved.status,
 			actorId: actor.id
 		});
+		if (saved.status === "scheduled") await this.arm(orgId, actor, saved, null);
 		return this.viewOf(orgId, actor, saved);
 	}
 	async update(orgId, postId, actor, patch) {
@@ -96,13 +112,12 @@ var PostServiceImpl = class {
 		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 retext = patch.title !== void 0 || patch.body !== void 0;
+		const candidates = retext ? await this.mentionable(orgId, post.spaceId, patch.title ?? post.title, patch.body ?? post.body) : [];
+		const updated = await this.uow.run(async ({ posts, mentions, 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)
-			})]);
+			const added = retext ? await mentions.sync(orgId, "post", postId, candidates, /* @__PURE__ */ new Date()) : [];
+			await outbox.append([this.updated(orgId, next, this.meta(actor, next.status === "pending" ? post.status : void 0), next.status === "published" ? keepAllowed(candidates, added) : [])]);
 			return next;
 		});
 		this.logger.info("post updated", {
@@ -125,6 +140,7 @@ var PostServiceImpl = class {
 			status: saved.status,
 			actorId: actor.id
 		});
+		if (post.status === "scheduled") await this.disarm(orgId, postId);
 		return this.viewOf(orgId, actor, saved);
 	}
 	async schedule(orgId, postId, actor, scheduledAt) {
@@ -133,17 +149,14 @@ var PostServiceImpl = class {
 		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, {
+			const next = await posts.updateIf(orgId, postId, { status: post.status }, {
 				status: "scheduled",
 				scheduledAt,
 				publishedAt: null,
 				removedBy: null
 			});
-			await outbox.append([discussionEvents.postUpdated.make({
-				orgId,
-				data: next,
-				metadata: this.meta(actor, post.status)
-			})]);
+			if (!next) throw new ConflictError("This post cannot be scheduled");
+			await outbox.append([this.updated(orgId, next, this.meta(actor, post.status))]);
 			return next;
 		});
 		this.logger.info("post scheduled", {
@@ -152,25 +165,132 @@ var PostServiceImpl = class {
 			scheduledAt: scheduledAt.toISOString(),
 			actorId: actor.id
 		});
+		await this.arm(orgId, actor, updated, post.status === "scheduled" ? post.scheduledAt : null);
+		return this.viewOf(orgId, actor, updated);
+	}
+	async unschedule(orgId, postId, actor) {
+		const { post } = await this.loadVisible(orgId, actor, postId);
+		this.assertAuthor(actor, post);
+		if (post.status !== "scheduled") throw new ConflictError("This post is not scheduled");
+		const updated = await this.uow.run(async ({ posts, outbox }) => {
+			const next = await posts.updateIf(orgId, postId, { status: "scheduled" }, DRAFT);
+			if (!next) throw new ConflictError("This post is not scheduled");
+			await outbox.append([this.updated(orgId, next, this.meta(actor, post.status))]);
+			return next;
+		});
+		this.logger.info("post unscheduled", {
+			orgId,
+			postId,
+			actorId: actor.id
+		});
+		await this.disarm(orgId, postId);
 		return this.viewOf(orgId, actor, updated);
 	}
+	async publishScheduled(orgId, postId, now) {
+		const post = await this.repo.find(orgId, postId);
+		if (!post || post.status !== "scheduled" || post.scheduledAt === null) {
+			this.logger.debug("scheduled post no longer scheduled", {
+				orgId,
+				postId
+			});
+			return;
+		}
+		if (post.scheduledAt > now) {
+			await this.scheduler.at(POST_PUBLISH_JOB, post.scheduledAt, postId, {
+				orgId,
+				postId
+			});
+			this.logger.info("scheduled post timer moved", {
+				orgId,
+				postId,
+				scheduledAt: post.scheduledAt.toISOString()
+			});
+			return;
+		}
+		const space = await this.content.getSpace(orgId, post.spaceId);
+		if (!space) {
+			this.logger.error("scheduled post has no space", {
+				orgId,
+				postId,
+				spaceId: post.spaceId
+			});
+			return;
+		}
+		const role = await this.authors.roleOf(orgId, post.orgUserId);
+		const refused = !await this.submittable(orgId, post, space, role);
+		const patch = refused ? DRAFT : this.submissionOf(space.settings.requireReview, role, now);
+		const saved = await this.uow.run(async ({ posts, mentions, outbox }) => {
+			const next = await posts.updateIf(orgId, postId, {
+				status: "scheduled",
+				dueBy: now
+			}, patch);
+			if (!next) return null;
+			await outbox.append([await this.landed(mentions, orgId, next, this.meta(null, post.status))]);
+			return next;
+		});
+		if (!saved) {
+			this.logger.debug("scheduled post already handled", {
+				orgId,
+				postId
+			});
+			return;
+		}
+		this.logger.info("scheduled post submitted", {
+			orgId,
+			postId,
+			status: saved.status,
+			refused
+		});
+	}
+	async arm(orgId, actor, post, previousScheduledAt) {
+		if (post.scheduledAt === null) return;
+		try {
+			await this.scheduler.at(POST_PUBLISH_JOB, post.scheduledAt, post.id, {
+				orgId,
+				postId: post.id
+			});
+			return;
+		} catch (err) {
+			this.logger.error("post timer not set", {
+				orgId,
+				postId: post.id,
+				err
+			});
+		}
+		await this.uow.run(async ({ posts, outbox }) => {
+			const reverted = await posts.updateIf(orgId, post.id, {
+				status: "scheduled",
+				scheduledAt: post.scheduledAt
+			}, previousScheduledAt ? { scheduledAt: previousScheduledAt } : DRAFT);
+			if (!reverted) return;
+			await outbox.append([this.updated(orgId, reverted, this.meta(actor, reverted.status === "draft" ? post.status : void 0))]);
+		});
+		throw new UnavailableError("The post could not be scheduled; try again", { postId: post.id });
+	}
+	async disarm(orgId, postId) {
+		try {
+			await this.scheduler.cancel(POST_PUBLISH_JOB, postId);
+		} catch (err) {
+			this.logger.warn("post timer not cancelled", {
+				orgId,
+				postId,
+				err
+			});
+		}
+	}
 	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 updated = await this.uow.run(async ({ posts, mentions, 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)
-			})]);
+			await outbox.append([await this.landed(mentions, orgId, next, this.meta(actor, post.status))]);
 			return next;
 		});
 		this.logger.info("post approved", {
@@ -218,16 +338,7 @@ var PostServiceImpl = class {
 		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]);
+			await outbox.append([next.status === "published" ? this.published(orgId, next, metadata, []) : this.updated(orgId, next, metadata)]);
 			return next;
 		});
 		this.logger.info("post restored", {
@@ -256,7 +367,20 @@ var PostServiceImpl = class {
 	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);
+		await this.uow.run(async ({ posts, outbox }) => {
+			if (!await posts.setReaction(orgId, postId, actor.id, emoji) || emoji === null) return;
+			await outbox.append([discussionEvents.postReactionAdded.make({
+				orgId,
+				data: {
+					postId,
+					spaceId: post.spaceId,
+					communityId: post.communityId,
+					orgUserId: actor.id,
+					reaction: emoji
+				},
+				metadata: this.meta(actor)
+			})]);
+		});
 		this.logger.debug("post reaction set", {
 			orgId,
 			postId,
@@ -264,24 +388,6 @@ var PostServiceImpl = class {
 		});
 		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);
@@ -452,82 +558,6 @@ var PostServiceImpl = class {
 	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, {
@@ -549,14 +579,16 @@ var PostServiceImpl = class {
 	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([
+		const now = /* @__PURE__ */ new Date();
+		const [records, reactions, commentCounts, subscribed, bookmarked, mentioned] = 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)
+			this.subscriptions.forViewer(orgId, actor.id, "post", postIds),
+			this.repo.bookmarkedAmong(orgId, postIds, actor.id),
+			mentionViews(this.mentions, this.profiles, orgId, "post", postIds)
 		]);
-		const following = new Set(followed);
+		const subscriptionOf = new Map(subscribed.map((row) => [row.itemId, row]));
 		const saved = new Set(bookmarked);
 		return posts.map((post) => {
 			const record = records[post.orgUserId];
@@ -569,25 +601,17 @@ var PostServiceImpl = class {
 				reactions: counts?.reactions ?? {},
 				viewerReaction: counts?.viewerReaction ?? null,
 				commentCount: commentCounts[post.id] ?? 0,
-				following: following.has(post.id),
-				bookmarked: saved.has(post.id)
+				subscription: activeSubscription(subscriptionOf.get(post.id), now),
+				bookmarked: saved.has(post.id),
+				mentions: mentioned[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 this.uow.run(async ({ posts, mentions, outbox }) => {
+			const next = await posts.updateIf(orgId, post.id, { status: post.status }, this.submissionOf(space.settings.requireReview, role, now));
+			if (!next) throw new ConflictError("This post cannot be submitted");
+			await outbox.append([await this.landed(mentions, orgId, next, this.meta(actor, post.status))]);
 			return next;
 		});
 	}
@@ -598,11 +622,7 @@ var PostServiceImpl = class {
 		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)
-			})]);
+			await outbox.append([this.updated(orgId, next, this.meta(actor, next.status === "pending" ? post.status : void 0))]);
 			return next;
 		});
 		this.logger.info(log, {
@@ -710,6 +730,38 @@ var PostServiceImpl = class {
 			return post[key] !== value;
 		});
 	}
+	async mentionable(orgId, spaceId, title, body) {
+		return this.openersOf(orgId, spaceId, mentionTokens(title, body));
+	}
+	async openersOf(orgId, spaceId, orgUserIds) {
+		if (orgUserIds.length === 0) return [];
+		return keepAllowed(orgUserIds, await this.access.spaceOpenersAmong(orgId, spaceId, orgUserIds));
+	}
+	async landed(mentions, orgId, post, metadata) {
+		if (post.status !== "published") return this.updated(orgId, post, metadata);
+		const mentioned = await this.openersOf(orgId, post.spaceId, await mentions.ofItem(orgId, "post", post.id));
+		return this.published(orgId, post, metadata, mentioned);
+	}
+	published(orgId, post, metadata, mentionedOrgUserIds) {
+		return discussionEvents.postPublished.make({
+			orgId,
+			data: {
+				...post,
+				mentionedOrgUserIds
+			},
+			metadata
+		});
+	}
+	updated(orgId, post, metadata, mentionedOrgUserIds = []) {
+		return discussionEvents.postUpdated.make({
+			orgId,
+			data: {
+				...post,
+				mentionedOrgUserIds
+			},
+			metadata
+		});
+	}
 	meta(actor, previousStatus) {
 		return {
 			...actor ? { actorOrgUserId: actor.id } : {},