@headless-lms/adapter-db 0.1.0 → 0.3.0

package/dist/repositories/content.js

@@ -1,14 +1,63 @@
-import { activities, activityAssets, contentItems, courses, downloadAssets, downloads, modules } from "../schema/content.js";
-import { isUniqueViolation } from "./pg-errors.js";
+import { activities, activityAssets, bundleItems, bundles, communities, contentItems, courses, downloadAssets, downloads, modules, spaceLinks, spaceTopics, spaces } from "../schema/content.js";
+import { posts } from "../schema/discussion.js";
+import { settings } from "../schema/settings.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 { noopLogger } from "@headless-lms/core/shared/logger";
 import { ConflictError, NotFoundError } from "@headless-lms/core/shared/errors";
+import { noopLogger } from "@headless-lms/core/shared/logger";
+import { communitySettingsDefaults, courseSettingsDefaults, spaceSettingsDefaults } from "@headless-lms/core/schemas";
 //#region src/repositories/content.ts
-function toCourse(row) {
+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 toCommunity(row, storedSettings) {
+	const raw = storedSettings?.dm;
+	const stored = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
 	return {
 		...row,
-		status: row.status
+		status: row.status,
+		settings: { dm: {
+			...communitySettingsDefaults.dm,
+			...stored
+		} }
+	};
+}
+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,
+		status: row.status,
+		settings: {
+			...courseSettingsDefaults,
+			...storedSettings
+		}
 	};
 }
 const sortColumns = {
@@ -33,6 +82,11 @@ function toDownload(row) {
 		status: row.status
 	};
 }
+const bundleSortColumns = {
+	name: bundles.name,
+	createdAt: bundles.createdAt,
+	updatedAt: bundles.updatedAt
+};
 var DrizzleContentRepository = class {
 	db;
 	logger;
@@ -45,7 +99,7 @@ var DrizzleContentRepository = class {
 	tx(fn) {
 		return this.db.transaction(fn);
 	}
-	async list(orgId, query) {
+	async listCourses(orgId, query) {
 		const conditions = [eq(courses.orgId, orgId)];
 		if (query.status) conditions.push(eq(courses.status, query.status));
 		if (query.category) conditions.push(eq(courses.category, query.category));
@@ -68,20 +122,26 @@ var DrizzleContentRepository = class {
 		}
 		const sortExpr = sortColumns[sortKey] ?? courses.createdAt;
 		const orderBy = direction === "desc" ? desc(sortExpr) : asc(sortExpr);
-		const rows = await this.db.select().from(courses).where(where).orderBy(orderBy).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
+		const rows = await this.db.select({
+			course: courses,
+			settingsValue: settings.value
+		}).from(courses).leftJoin(settings, courseSettingsJoin).where(where).orderBy(orderBy).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
 		const [totalRow] = await this.db.select({ value: count() }).from(courses).where(where);
 		return {
-			rows: rows.map(toCourse),
+			rows: rows.map((row) => toCourse(row.course, row.settingsValue)),
 			total: totalRow?.value ?? 0,
 			page: query.page,
 			pageSize: query.pageSize
 		};
 	}
-	async findById(orgId, id) {
-		const [row] = await this.db.select().from(courses).where(and(eq(courses.orgId, orgId), eq(courses.id, id))).limit(1);
-		return row ? toCourse(row) : null;
+	async findCourseById(orgId, id) {
+		const [row] = await this.db.select({
+			course: courses,
+			settingsValue: settings.value
+		}).from(courses).leftJoin(settings, courseSettingsJoin).where(and(eq(courses.orgId, orgId), eq(courses.id, id))).limit(1);
+		return row ? toCourse(row.course, row.settingsValue) : null;
 	}
-	async create(orgId, input, slug) {
+	async createCourse(orgId, input, slug) {
 		const id = genId("course");
 		await this.db.insert(contentItems).values({
 			orgId,
@@ -97,31 +157,68 @@ var DrizzleContentRepository = class {
 			category: input.category ?? ""
 		}).returning({ id: courses.id });
 		if (!inserted) throw new Error("failed to insert course");
-		const created = await this.findById(orgId, inserted.id);
+		const created = await this.findCourseById(orgId, inserted.id);
 		if (!created) throw new Error("failed to load created course");
 		return created;
 	}
-	async update(orgId, id, patch) {
+	async updateCourse(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.category !== void 0) set.category = patch.category;
 		if (patch.status !== void 0) set.status = patch.status;
 		if (patch.thumbnailAssetId !== void 0) set.thumbnailAssetId = patch.thumbnailAssetId;
-		if (patch.settings !== void 0) set.settings = sql`${courses.settings} || ${JSON.stringify(patch.settings)}::jsonb`;
 		const [updated] = await this.db.update(courses).set(set).where(and(eq(courses.orgId, orgId), eq(courses.id, id))).returning({ id: courses.id });
 		if (!updated) return null;
-		return this.findById(orgId, id);
+		return this.findCourseById(orgId, id);
+	}
+	async patchCourseSettings(orgId, id, value) {
+		const key = and(eq(settings.orgId, orgId), eq(settings.namespace, SETTINGS_NAMESPACE), eq(settings.scopeId, id));
+		const merged = await this.tx(async (tx) => {
+			let [existing] = await tx.select().from(settings).where(key).for("update");
+			if (!existing) {
+				const [inserted] = await tx.insert(settings).values({
+					orgId,
+					namespace: SETTINGS_NAMESPACE,
+					scopeId: id,
+					value
+				}).onConflictDoNothing().returning();
+				if (inserted) return inserted.value;
+				[existing] = await tx.select().from(settings).where(key).for("update");
+				if (!existing) throw new Error("course settings patch: row vanished mid-transaction");
+			}
+			const [updated] = await tx.update(settings).set({
+				value: deepMerge(existing.value, value),
+				updatedAt: /* @__PURE__ */ new Date()
+			}).where(key).returning();
+			if (!updated) throw new Error("course settings patch returned no row");
+			return updated.value;
+		});
+		return {
+			...courseSettingsDefaults,
+			...merged
+		};
 	}
-	async delete(orgId, id) {
+	async deleteCourse(orgId, id) {
 		return (await this.db.delete(contentItems).where(and(eq(contentItems.orgId, orgId), eq(contentItems.id, id), eq(contentItems.type, "course"))).returning({ id: contentItems.id })).length > 0;
 	}
-	listForCourse(orgId, courseId) {
+	listCourseModules(orgId, courseId) {
 		return this.tx((tx) => this.listModules(tx, orgId, courseId));
 	}
 	async listActivitiesForCourse(orgId, courseId) {
 		return this.db.select().from(activities).where(and(eq(activities.orgId, orgId), eq(activities.courseId, courseId))).orderBy(activities.moduleId, activities.seq);
 	}
+	async listActivityAssetsForCourse(orgId, courseId) {
+		return this.db.select({
+			orgId: activityAssets.orgId,
+			id: activityAssets.id,
+			activityId: activityAssets.activityId,
+			assetId: activityAssets.assetId,
+			seq: activityAssets.seq,
+			createdAt: activityAssets.createdAt,
+			updatedAt: activityAssets.updatedAt
+		}).from(activityAssets).innerJoin(activities, and(eq(activities.orgId, activityAssets.orgId), eq(activities.id, activityAssets.activityId))).where(and(eq(activityAssets.orgId, orgId), eq(activities.courseId, courseId))).orderBy(activityAssets.activityId, activityAssets.seq);
+	}
 	async findActivity(orgId, activityId) {
 		const [row] = await this.db.select().from(activities).where(and(eq(activities.orgId, orgId), eq(activities.id, activityId))).limit(1);
 		return row ?? null;
@@ -142,12 +239,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) => {
@@ -343,7 +444,340 @@ var DrizzleContentRepository = class {
 		for (const [seq, assetId] of assetIds.entries()) await this.db.update(downloadAssets).set({ seq }).where(and(eq(downloadAssets.orgId, orgId), eq(downloadAssets.downloadId, downloadId), eq(downloadAssets.assetId, assetId)));
 		return this.listDownloadAssets(orgId, downloadId);
 	}
+	async listBundles(orgId, query) {
+		const conditions = [eq(bundles.orgId, orgId)];
+		const search = query.search?.trim();
+		if (search) conditions.push(ilike(bundles.name, `%${search}%`));
+		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 bundleSortColumns) {
+				sortKey = key;
+				direction = isDesc ? "desc" : "asc";
+			}
+		}
+		const sortExpr = bundleSortColumns[sortKey] ?? bundles.createdAt;
+		const orderBy = direction === "desc" ? desc(sortExpr) : asc(sortExpr);
+		const rows = await this.db.select().from(bundles).where(where).orderBy(orderBy).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
+		const [totalRow] = await this.db.select({ value: count() }).from(bundles).where(where);
+		return {
+			rows,
+			total: totalRow?.value ?? 0,
+			page: query.page,
+			pageSize: query.pageSize
+		};
+	}
+	async findBundleById(orgId, id) {
+		const [row] = await this.db.select().from(bundles).where(and(eq(bundles.orgId, orgId), eq(bundles.id, id))).limit(1);
+		return row ?? null;
+	}
+	/** The bundle and its initial items are one write: an unknown content id
+	*  rolls the bundle back rather than leaving it created and half-filled. */
+	async createBundle(orgId, input) {
+		const contentIds = [...new Set(input.contentIds ?? [])];
+		return this.tx(async (tx) => {
+			const [row] = await tx.insert(bundles).values({
+				orgId,
+				id: genId("bundle"),
+				name: input.name
+			}).returning();
+			if (!row) throw new Error("failed to load created bundle");
+			if (contentIds.length > 0) {
+				const found = await tx.select({ id: contentItems.id }).from(contentItems).where(and(eq(contentItems.orgId, orgId), inArray(contentItems.id, contentIds)));
+				const known = new Set(found.map((item) => item.id));
+				const missing = contentIds.find((id) => !known.has(id));
+				if (missing) throw new NotFoundError("Content", missing);
+				await tx.insert(bundleItems).values(contentIds.map((contentId) => ({
+					orgId,
+					bundleId: row.id,
+					contentId
+				})));
+			}
+			return row;
+		});
+	}
+	async updateBundle(orgId, id, patch) {
+		const set = { updatedAt: /* @__PURE__ */ new Date() };
+		if (patch.name !== void 0) set.name = patch.name;
+		const [row] = await this.db.update(bundles).set(set).where(and(eq(bundles.orgId, orgId), eq(bundles.id, id))).returning();
+		return row ?? null;
+	}
+	async deleteBundle(orgId, id) {
+		return (await this.db.delete(bundles).where(and(eq(bundles.orgId, orgId), eq(bundles.id, id))).returning({ id: bundles.id })).length > 0;
+	}
+	async listBundleItems(orgId, bundleId) {
+		return this.db.select().from(bundleItems).where(and(eq(bundleItems.orgId, orgId), eq(bundleItems.bundleId, bundleId))).orderBy(asc(bundleItems.createdAt));
+	}
+	/** Assert the bundle exists in the org; throw otherwise. */
+	async assertBundle(orgId, bundleId) {
+		const [row] = await this.db.select({ id: bundles.id }).from(bundles).where(and(eq(bundles.orgId, orgId), eq(bundles.id, bundleId))).limit(1);
+		if (!row) throw new NotFoundError("Bundle", bundleId);
+	}
+	async addBundleItem(orgId, bundleId, contentId) {
+		await this.assertBundle(orgId, bundleId);
+		const [item] = await this.db.select({ id: contentItems.id }).from(contentItems).where(and(eq(contentItems.orgId, orgId), eq(contentItems.id, contentId))).limit(1);
+		if (!item) throw new NotFoundError("Content", contentId);
+		await this.db.insert(bundleItems).values({
+			orgId,
+			bundleId,
+			contentId
+		}).onConflictDoNothing({ target: [
+			bundleItems.orgId,
+			bundleItems.bundleId,
+			bundleItems.contentId
+		] });
+		return this.listBundleItems(orgId, bundleId);
+	}
+	async removeBundleItem(orgId, bundleId, contentId) {
+		await this.assertBundle(orgId, bundleId);
+		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 listPublishedCommunityIds(orgId) {
+		return (await this.db.select({ id: communities.id }).from(communities).where(and(eq(communities.orgId, orgId), eq(communities.status, "published"))).orderBy(asc(communities.createdAt), asc(communities.id))).map((row) => row.id);
+	}
+	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 patchDmSettings(orgId, id, patch) {
+		if (!await this.findCommunityById(orgId, id)) return null;
+		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 = { dm: 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, { dm: 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
 export { DrizzleContentRepository };