@headless-lms/adapter-db 0.2.0 → 0.4.0

package/dist/repositories/content.js

@@ -1,15 +1,62 @@
-import { activities, activityAssets, bundleItems, bundles, contentItems, courses, downloadAssets, downloads, modules } from "../schema/content.js";
+import { activities, activityAssets, bundleItems, bundles, communities, contentItems, courses, downloadAssets, downloads, modules, spaceLinks, spaceTopics, spaces } from "../schema/content.js";
 import { settings } from "../schema/settings.js";
-import { isUniqueViolation, translateDbErrors } from "./pg-errors.js";
+import { posts } from "../schema/discussion.js";
+import { isUniqueViolation, pgErrorFields, translateDbErrors } from "./pg-errors.js";
 import { deepMerge } from "./settings.js";
 import { and, asc, count, desc, eq, ilike, inArray, or, sql } from "drizzle-orm";
 import { genId } from "@headless-lms/core/shared/id";
 import { ConflictError, NotFoundError } from "@headless-lms/core/shared/errors";
 import { noopLogger } from "@headless-lms/core/shared/logger";
-import { courseSettingsDefaults } from "@headless-lms/core/schemas";
+import { communitySettingsDefaults, courseSettingsDefaults, digestScheduleSchema, spaceSettingsDefaults } from "@headless-lms/core/schemas";
 //#region src/repositories/content.ts
+const LIBRARY_ONLY = "An activity can only use ready files from the media library";
+const MISSING_ASSET_DETAIL = /^Key \(org_id, asset_id\)=\((?:[^,]+), (.+?)\) is not present/;
+function refusedLink(err) {
+	const pg = pgErrorFields(err);
+	if (pg?.code !== "23503") return;
+	const missing = pg.detail?.match(MISSING_ASSET_DETAIL)?.[1];
+	const message = missing ? `${LIBRARY_ONLY}. Not available: ${missing}` : LIBRARY_ONLY;
+	return Object.assign(new ConflictError(message), { cause: err });
+}
 const SETTINGS_NAMESPACE = "content";
 const courseSettingsJoin = and(eq(settings.orgId, courses.orgId), eq(settings.namespace, SETTINGS_NAMESPACE), eq(settings.scopeId, courses.id));
+const communitySettingsJoin = and(eq(settings.orgId, communities.orgId), eq(settings.namespace, SETTINGS_NAMESPACE), eq(settings.scopeId, communities.id));
+function storedDigest(value) {
+	const parsed = digestScheduleSchema.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
+function toCommunity(row, storedSettings) {
+	const raw = storedSettings?.dm;
+	const stored = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+	return {
+		...row,
+		status: row.status,
+		settings: {
+			dm: {
+				...communitySettingsDefaults.dm,
+				...stored
+			},
+			digest: storedDigest(storedSettings?.digest)
+		}
+	};
+}
+function toSpace(row) {
+	return {
+		...row,
+		accessRule: row.accessRule,
+		settings: {
+			...spaceSettingsDefaults,
+			...row.settings
+		}
+	};
+}
+const communitySortColumns = {
+	title: communities.title,
+	slug: communities.slug,
+	status: communities.status,
+	createdAt: communities.createdAt,
+	updatedAt: communities.updatedAt
+};
 function toCourse(row, storedSettings) {
 	return {
 		...row,
@@ -199,12 +246,16 @@ var DrizzleContentRepository = class {
 	/** Replace an activity's ordered asset links with `assetIds`. */
 	async replaceActivityAssets(tx, orgId, activityId, assetIds) {
 		await tx.delete(activityAssets).where(and(eq(activityAssets.orgId, orgId), eq(activityAssets.activityId, activityId)));
-		if (assetIds.length) await tx.insert(activityAssets).values(assetIds.map((assetId, i) => ({
-			orgId,
-			activityId,
-			assetId,
-			seq: i
-		})));
+		if (assetIds.length) try {
+			await tx.insert(activityAssets).values(assetIds.map((assetId, i) => ({
+				orgId,
+				activityId,
+				assetId,
+				seq: i
+			})));
+		} catch (err) {
+			throw refusedLink(err) ?? err;
+		}
 	}
 	createModule(orgId, courseId, title) {
 		return this.tx(async (tx) => {
@@ -492,6 +543,262 @@ var DrizzleContentRepository = class {
 		await this.db.delete(bundleItems).where(and(eq(bundleItems.orgId, orgId), eq(bundleItems.bundleId, bundleId), eq(bundleItems.contentId, contentId)));
 		return this.listBundleItems(orgId, bundleId);
 	}
+	async listCommunities(orgId, query) {
+		const conditions = [eq(communities.orgId, orgId)];
+		if (query.status) conditions.push(eq(communities.status, query.status));
+		const search = query.search?.trim();
+		if (search) {
+			const like = `%${search}%`;
+			const match = or(ilike(communities.title, like), ilike(communities.description, like));
+			if (match) conditions.push(match);
+		}
+		const where = and(...conditions);
+		let sortKey = "createdAt";
+		let direction = "desc";
+		if (query.sort) {
+			const isDesc = query.sort.startsWith("-");
+			const key = isDesc ? query.sort.slice(1) : query.sort;
+			if (key in communitySortColumns) {
+				sortKey = key;
+				direction = isDesc ? "desc" : "asc";
+			}
+		}
+		const sortExpr = communitySortColumns[sortKey] ?? communities.createdAt;
+		const orderBy = direction === "desc" ? desc(sortExpr) : asc(sortExpr);
+		const rows = await this.db.select({
+			community: communities,
+			settingsValue: settings.value
+		}).from(communities).leftJoin(settings, communitySettingsJoin).where(where).orderBy(orderBy).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
+		const [totalRow] = await this.db.select({ value: count() }).from(communities).where(where);
+		return {
+			rows: rows.map((row) => toCommunity(row.community, row.settingsValue)),
+			total: totalRow?.value ?? 0,
+			page: query.page,
+			pageSize: query.pageSize
+		};
+	}
+	async findCommunityById(orgId, id) {
+		const [row] = await this.db.select({
+			community: communities,
+			settingsValue: settings.value
+		}).from(communities).leftJoin(settings, communitySettingsJoin).where(and(eq(communities.orgId, orgId), eq(communities.id, id))).limit(1);
+		return row ? toCommunity(row.community, row.settingsValue) : null;
+	}
+	async findCommunitiesByIds(orgId, ids) {
+		return (await this.db.select({
+			community: communities,
+			settingsValue: settings.value
+		}).from(communities).leftJoin(settings, communitySettingsJoin).where(and(eq(communities.orgId, orgId), inArray(communities.id, ids))).orderBy(asc(communities.title), asc(communities.id))).map((row) => toCommunity(row.community, row.settingsValue));
+	}
+	async createCommunity(orgId, input, slug) {
+		const id = genId("community");
+		await this.db.insert(contentItems).values({
+			orgId,
+			id,
+			type: "community"
+		});
+		const [inserted] = await this.db.insert(communities).values({
+			orgId,
+			id,
+			title: input.title,
+			slug,
+			description: input.description ?? ""
+		}).returning({ id: communities.id });
+		if (!inserted) throw new Error("failed to insert community");
+		const created = await this.findCommunityById(orgId, inserted.id);
+		if (!created) throw new Error("failed to load created community");
+		return created;
+	}
+	async updateCommunity(orgId, id, patch) {
+		const set = { updatedAt: /* @__PURE__ */ new Date() };
+		if (patch.title !== void 0) set.title = patch.title;
+		if (patch.description !== void 0) set.description = patch.description;
+		if (patch.status !== void 0) set.status = patch.status;
+		if (patch.thumbnailAssetId !== void 0) set.thumbnailAssetId = patch.thumbnailAssetId;
+		const [updated] = await this.db.update(communities).set(set).where(and(eq(communities.orgId, orgId), eq(communities.id, id))).returning({ id: communities.id });
+		if (!updated) return null;
+		return this.findCommunityById(orgId, id);
+	}
+	async communitiesWithDigest() {
+		return (await this.db.select({
+			orgId: communities.orgId,
+			communityId: communities.id,
+			digest: sql`${settings.value} -> 'digest'`
+		}).from(communities).innerJoin(settings, communitySettingsJoin).where(and(eq(communities.status, "published"), sql`jsonb_typeof(${settings.value} -> 'digest') = 'object'`)).orderBy(asc(communities.orgId), asc(communities.id))).flatMap((row) => {
+			const digest = storedDigest(row.digest);
+			return digest ? [{
+				orgId: row.orgId,
+				communityId: row.communityId,
+				digest
+			}] : [];
+		});
+	}
+	async patchCommunitySettings(orgId, id, input) {
+		if (!await this.findCommunityById(orgId, id)) return null;
+		const { digest, ...dm } = input;
+		const patch = digest === void 0 ? { dm } : {
+			dm,
+			digest
+		};
+		const key = and(eq(settings.orgId, orgId), eq(settings.namespace, SETTINGS_NAMESPACE), eq(settings.scopeId, id));
+		await this.tx(async (tx) => {
+			let [existing] = await tx.select().from(settings).where(key).for("update");
+			const value = patch;
+			if (!existing) {
+				const [inserted] = await tx.insert(settings).values({
+					orgId,
+					namespace: SETTINGS_NAMESPACE,
+					scopeId: id,
+					value
+				}).onConflictDoNothing().returning();
+				if (inserted) return;
+				[existing] = await tx.select().from(settings).where(key).for("update");
+				if (!existing) throw new Error("community settings patch: row vanished mid-transaction");
+			}
+			await tx.update(settings).set({
+				value: deepMerge(existing.value, patch),
+				updatedAt: /* @__PURE__ */ new Date()
+			}).where(key);
+		});
+		return this.findCommunityById(orgId, id);
+	}
+	async deleteCommunity(orgId, id) {
+		return (await this.db.delete(contentItems).where(and(eq(contentItems.orgId, orgId), eq(contentItems.id, id), eq(contentItems.type, "community"))).returning({ id: contentItems.id })).length > 0;
+	}
+	async deleteCommunitySettings(orgId, id) {
+		await this.db.delete(settings).where(and(eq(settings.orgId, orgId), eq(settings.namespace, SETTINGS_NAMESPACE), eq(settings.scopeId, id)));
+	}
+	async listSpaces(orgId, communityId) {
+		const rows = await this.db.select().from(spaces).where(and(eq(spaces.orgId, orgId), eq(spaces.communityId, communityId))).orderBy(asc(spaces.seq));
+		return this.withSpaceParts(orgId, rows.map(toSpace));
+	}
+	async findSpace(orgId, spaceId) {
+		const [row] = await this.db.select().from(spaces).where(and(eq(spaces.orgId, orgId), eq(spaces.id, spaceId))).limit(1);
+		if (!row) return null;
+		const [detail] = await this.withSpaceParts(orgId, [toSpace(row)]);
+		return detail ?? null;
+	}
+	async lockSpace(orgId, spaceId) {
+		const [row] = await this.db.select().from(spaces).where(and(eq(spaces.orgId, orgId), eq(spaces.id, spaceId))).for("update").limit(1);
+		return row ? toSpace(row) : null;
+	}
+	async createSpace(orgId, communityId, input) {
+		const nextSeq = (await this.db.select({ seq: spaces.seq }).from(spaces).where(and(eq(spaces.orgId, orgId), eq(spaces.communityId, communityId)))).reduce((max, row) => Math.max(max, row.seq), -1) + 1;
+		const [inserted] = await this.db.insert(spaces).values({
+			orgId,
+			communityId,
+			name: input.name,
+			description: input.description ?? "",
+			seq: nextSeq,
+			accessRule: input.accessRule ?? "all_members",
+			capacity: input.capacity ?? null,
+			settings: {
+				...spaceSettingsDefaults,
+				...input.settings
+			}
+		}).returning({ id: spaces.id });
+		if (!inserted) throw new Error("failed to insert space");
+		const created = await this.findSpace(orgId, inserted.id);
+		if (!created) throw new Error("failed to load created space");
+		return created;
+	}
+	async updateSpace(orgId, communityId, spaceId, patch) {
+		const set = { updatedAt: /* @__PURE__ */ new Date() };
+		if (patch.name !== void 0) set.name = patch.name;
+		if (patch.description !== void 0) set.description = patch.description;
+		if (patch.accessRule !== void 0) set.accessRule = patch.accessRule;
+		if (patch.capacity !== void 0) set.capacity = patch.capacity;
+		if (patch.settings !== void 0) set.settings = {
+			...spaceSettingsDefaults,
+			...patch.settings
+		};
+		const [updated] = await this.db.update(spaces).set(set).where(and(eq(spaces.orgId, orgId), eq(spaces.id, spaceId), eq(spaces.communityId, communityId))).returning({ id: spaces.id });
+		if (!updated) return null;
+		return this.findSpace(orgId, spaceId);
+	}
+	async deleteSpace(orgId, communityId, spaceId) {
+		return (await this.db.delete(spaces).where(and(eq(spaces.orgId, orgId), eq(spaces.id, spaceId), eq(spaces.communityId, communityId))).returning({ id: spaces.id })).length > 0;
+	}
+	async reorderSpaces(orgId, communityId, orderedIds) {
+		for (let i = 0; i < orderedIds.length; i++) await this.db.update(spaces).set({ seq: i }).where(and(eq(spaces.orgId, orgId), eq(spaces.communityId, communityId), eq(spaces.id, orderedIds[i])));
+		return this.listSpaces(orgId, communityId);
+	}
+	async setSpaceTopics(orgId, spaceId, input) {
+		await this.tx(async (tx) => {
+			const existing = await tx.select({ id: spaceTopics.id }).from(spaceTopics).where(and(eq(spaceTopics.orgId, orgId), eq(spaceTopics.spaceId, spaceId))).for("update");
+			const kept = new Set(input.topics.flatMap((topic) => topic.id ? [topic.id] : []));
+			const known = new Set(existing.map((topic) => topic.id));
+			for (const id of kept) if (!known.has(id)) throw new NotFoundError("Topic", id);
+			const removed = existing.filter((topic) => !kept.has(topic.id)).map((topic) => topic.id);
+			if (removed.length) await tx.delete(spaceTopics).where(and(eq(spaceTopics.orgId, orgId), inArray(spaceTopics.id, removed)));
+			for (let seq = 0; seq < input.topics.length; seq++) {
+				const topic = input.topics[seq];
+				if (topic.id) await tx.update(spaceTopics).set({
+					name: topic.name,
+					seq,
+					updatedAt: /* @__PURE__ */ new Date()
+				}).where(and(eq(spaceTopics.orgId, orgId), eq(spaceTopics.id, topic.id)));
+				else await tx.insert(spaceTopics).values({
+					orgId,
+					spaceId,
+					name: topic.name,
+					seq
+				});
+			}
+		});
+		const space = await this.findSpace(orgId, spaceId);
+		if (!space) throw new NotFoundError("Space", spaceId);
+		return space;
+	}
+	async topicsInUse(orgId, spaceId, topicIds) {
+		if (topicIds.length === 0) return [];
+		await this.db.select({ id: spaceTopics.id }).from(spaceTopics).where(and(eq(spaceTopics.orgId, orgId), eq(spaceTopics.spaceId, spaceId), inArray(spaceTopics.id, topicIds))).for("update");
+		return (await this.db.selectDistinct({ topicId: posts.topicId }).from(posts).where(and(eq(posts.orgId, orgId), eq(posts.spaceId, spaceId), inArray(posts.topicId, topicIds)))).flatMap((row) => row.topicId ? [row.topicId] : []);
+	}
+	async addSpaceLink(orgId, spaceId, contentId) {
+		const [item] = await this.db.select({
+			id: contentItems.id,
+			type: contentItems.type
+		}).from(contentItems).where(and(eq(contentItems.orgId, orgId), eq(contentItems.id, contentId))).limit(1);
+		if (!item || item.type !== "course" && item.type !== "download" && item.type !== "community") throw new NotFoundError("Content", contentId);
+		const nextSeq = (await this.db.select({ seq: spaceLinks.seq }).from(spaceLinks).where(and(eq(spaceLinks.orgId, orgId), eq(spaceLinks.spaceId, spaceId)))).reduce((max, row) => Math.max(max, row.seq), -1) + 1;
+		await this.db.insert(spaceLinks).values({
+			orgId,
+			spaceId,
+			contentId,
+			seq: nextSeq
+		});
+		const space = await this.findSpace(orgId, spaceId);
+		if (!space) throw new NotFoundError("Space", spaceId);
+		return space;
+	}
+	async removeSpaceLink(orgId, spaceId, linkId) {
+		if ((await this.db.delete(spaceLinks).where(and(eq(spaceLinks.orgId, orgId), eq(spaceLinks.spaceId, spaceId), eq(spaceLinks.id, linkId))).returning({ id: spaceLinks.id })).length === 0) throw new NotFoundError("Link", linkId);
+		const space = await this.findSpace(orgId, spaceId);
+		if (!space) throw new NotFoundError("Space", spaceId);
+		return space;
+	}
+	async reorderSpaceLinks(orgId, spaceId, orderedIds) {
+		for (let i = 0; i < orderedIds.length; i++) await this.db.update(spaceLinks).set({ seq: i }).where(and(eq(spaceLinks.orgId, orgId), eq(spaceLinks.spaceId, spaceId), eq(spaceLinks.id, orderedIds[i])));
+		const space = await this.findSpace(orgId, spaceId);
+		if (!space) throw new NotFoundError("Space", spaceId);
+		return space;
+	}
+	async spacesLinkingContent(orgId, contentId) {
+		const rows = await this.db.select({ spaceId: spaceLinks.spaceId }).from(spaceLinks).where(and(eq(spaceLinks.orgId, orgId), eq(spaceLinks.contentId, contentId)));
+		return [...new Set(rows.map((row) => row.spaceId))];
+	}
+	async withSpaceParts(orgId, rows) {
+		if (rows.length === 0) return [];
+		const ids = rows.map((row) => row.id);
+		const topics = await this.db.select().from(spaceTopics).where(and(eq(spaceTopics.orgId, orgId), inArray(spaceTopics.spaceId, ids))).orderBy(asc(spaceTopics.seq));
+		const links = await this.db.select().from(spaceLinks).where(and(eq(spaceLinks.orgId, orgId), inArray(spaceLinks.spaceId, ids))).orderBy(asc(spaceLinks.seq));
+		return rows.map((space) => ({
+			...space,
+			topics: topics.filter((topic) => topic.spaceId === space.id),
+			links: links.filter((link) => link.spaceId === space.id)
+		}));
+	}
 };
 translateDbErrors(DrizzleContentRepository);
 //#endregion