@headless-lms/adapter-db 0.3.0 → 0.5.0

package/dist/repositories/content.js

@@ -1,13 +1,13 @@
-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 { activities, activityAssets, bundleItems, bundles, communities, contentItems, courses, downloadAssets, downloads, eventAssets, events, modules, spaceLinks, spaceTopics, spaces } from "../schema/content.js";
 import { settings } from "../schema/settings.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 { noopLogger } from "@headless-lms/core/shared/logger";
+import { and, asc, count, desc, eq, gt, ilike, inArray, lt, 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 { communitySettingsDefaults, courseSettingsDefaults, spaceSettingsDefaults } from "@headless-lms/core/schemas";
+import { communitySettingsDefaults, courseSettingsDefaults, digestScheduleSchema, eventSettingsDefaults, 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/;
@@ -21,16 +21,38 @@ function refusedLink(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));
+const eventSettingsJoin = and(eq(settings.orgId, events.orgId), eq(settings.namespace, SETTINGS_NAMESPACE), eq(settings.scopeId, events.id));
+function toEvent(row, storedSettings) {
+	return {
+		...row,
+		status: row.status,
+		settings: {
+			...eventSettingsDefaults,
+			...storedSettings
+		}
+	};
+}
+const eventSortColumns = {
+	startsAt: events.startsAt,
+	title: events.title
+};
+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
-		} }
+		settings: {
+			dm: {
+				...communitySettingsDefaults.dm,
+				...stored
+			},
+			digest: storedDigest(storedSettings?.digest)
+		}
 	};
 }
 function toSpace(row) {
@@ -99,8 +121,15 @@ var DrizzleContentRepository = class {
 	tx(fn) {
 		return this.db.transaction(fn);
 	}
-	async listCourses(orgId, query) {
+	async listCourses(orgId, query, ids) {
+		if (ids?.length === 0) return {
+			rows: [],
+			total: 0,
+			page: query.page,
+			pageSize: query.pageSize
+		};
 		const conditions = [eq(courses.orgId, orgId)];
+		if (ids) conditions.push(inArray(courses.id, ids));
 		if (query.status) conditions.push(eq(courses.status, query.status));
 		if (query.category) conditions.push(eq(courses.category, query.category));
 		const search = query.search?.trim();
@@ -173,27 +202,7 @@ var DrizzleContentRepository = class {
 		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;
-		});
+		const merged = await this.patchSettings(orgId, id, value);
 		return {
 			...courseSettingsDefaults,
 			...merged
@@ -334,8 +343,15 @@ var DrizzleContentRepository = class {
 			return this.listModules(tx, orgId, courseId);
 		});
 	}
-	async listDownloads(orgId, query) {
+	async listDownloads(orgId, query, ids) {
+		if (ids?.length === 0) return {
+			rows: [],
+			total: 0,
+			page: query.page,
+			pageSize: query.pageSize
+		};
 		const conditions = [eq(downloads.orgId, orgId)];
+		if (ids) conditions.push(inArray(downloads.id, ids));
 		if (query.status) conditions.push(eq(downloads.status, query.status));
 		if (query.category) conditions.push(eq(downloads.category, query.category));
 		const search = query.search?.trim();
@@ -444,6 +460,144 @@ 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 listEvents(orgId, query, ids) {
+		if (ids?.length === 0) return {
+			rows: [],
+			total: 0,
+			page: query.page,
+			pageSize: query.pageSize
+		};
+		const conditions = [eq(events.orgId, orgId)];
+		if (ids) conditions.push(inArray(events.id, ids));
+		if (query.status) conditions.push(eq(events.status, query.status));
+		if (query.from) conditions.push(gt(events.endsAt, query.from));
+		if (query.to) conditions.push(lt(events.startsAt, query.to));
+		const search = query.search?.trim();
+		if (search) conditions.push(ilike(events.title, `%${search}%`));
+		const where = and(...conditions);
+		const sort = query.sort ?? "startsAt";
+		const isDesc = sort.startsWith("-");
+		const sortExpr = eventSortColumns[isDesc ? sort.slice(1) : sort] ?? events.startsAt;
+		const direction = isDesc ? desc : asc;
+		const rows = await this.db.select({
+			event: events,
+			settingsValue: settings.value
+		}).from(events).leftJoin(settings, eventSettingsJoin).where(where).orderBy(direction(sortExpr), direction(events.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize);
+		const [totalRow] = await this.db.select({ value: count() }).from(events).where(where);
+		return {
+			rows: rows.map((row) => toEvent(row.event, row.settingsValue)),
+			total: totalRow?.value ?? 0,
+			page: query.page,
+			pageSize: query.pageSize
+		};
+	}
+	async findEventById(orgId, id) {
+		const [row] = await this.db.select({
+			event: events,
+			settingsValue: settings.value
+		}).from(events).leftJoin(settings, eventSettingsJoin).where(and(eq(events.orgId, orgId), eq(events.id, id))).limit(1);
+		return row ? toEvent(row.event, row.settingsValue) : null;
+	}
+	async findEventsByIds(orgId, ids) {
+		return (await this.db.select({
+			event: events,
+			settingsValue: settings.value
+		}).from(events).leftJoin(settings, eventSettingsJoin).where(and(eq(events.orgId, orgId), inArray(events.id, ids)))).map((row) => toEvent(row.event, row.settingsValue));
+	}
+	async createEvent(orgId, input) {
+		const id = genId("contentEvent");
+		await this.db.insert(contentItems).values({
+			orgId,
+			id,
+			type: "event"
+		});
+		await this.db.insert(events).values({
+			orgId,
+			id,
+			title: input.title,
+			description: input.description ?? "",
+			startsAt: input.startsAt,
+			endsAt: input.endsAt,
+			timeZone: input.timeZone,
+			...input.location && { location: input.location }
+		});
+		const created = await this.findEventById(orgId, id);
+		if (!created) throw new Error("failed to load created event");
+		return created;
+	}
+	async updateEvent(orgId, id, patch) {
+		const set = { updatedAt: /* @__PURE__ */ new Date() };
+		for (const key of [
+			"title",
+			"description",
+			"startsAt",
+			"endsAt",
+			"timeZone",
+			"location",
+			"thumbnailAssetId",
+			"recording",
+			"status"
+		]) if (patch[key] !== void 0) set[key] = patch[key];
+		const [updated] = await this.db.update(events).set(set).where(and(eq(events.orgId, orgId), eq(events.id, id))).returning({ id: events.id });
+		if (!updated) return null;
+		return this.findEventById(orgId, id);
+	}
+	async patchEventSettings(orgId, id, value) {
+		const merged = await this.patchSettings(orgId, id, value);
+		return {
+			...eventSettingsDefaults,
+			...merged
+		};
+	}
+	async deleteEvent(orgId, id) {
+		return (await this.db.delete(contentItems).where(and(eq(contentItems.orgId, orgId), eq(contentItems.id, id), eq(contentItems.type, "event"))).returning({ id: contentItems.id })).length > 0;
+	}
+	async deleteEventSettings(orgId, id) {
+		await this.db.delete(settings).where(and(eq(settings.orgId, orgId), eq(settings.namespace, SETTINGS_NAMESPACE), eq(settings.scopeId, id)));
+	}
+	async listEventAssets(orgId, eventId) {
+		return this.db.select().from(eventAssets).where(and(eq(eventAssets.orgId, orgId), eq(eventAssets.eventId, eventId))).orderBy(asc(eventAssets.seq));
+	}
+	async listEventAssetsFor(orgId, eventIds) {
+		return this.db.select().from(eventAssets).where(and(eq(eventAssets.orgId, orgId), inArray(eventAssets.eventId, eventIds))).orderBy(asc(eventAssets.eventId), asc(eventAssets.seq));
+	}
+	async assertEvent(orgId, eventId) {
+		const [row] = await this.db.select({ id: events.id }).from(events).where(and(eq(events.orgId, orgId), eq(events.id, eventId))).limit(1);
+		if (!row) throw new NotFoundError("Event", eventId);
+	}
+	async addEventAsset(orgId, eventId, input) {
+		await this.assertEvent(orgId, eventId);
+		const [maxRow] = await this.db.select({ maxSeq: sql`max(${eventAssets.seq})` }).from(eventAssets).where(and(eq(eventAssets.orgId, orgId), eq(eventAssets.eventId, eventId)));
+		const nextSeq = (maxRow?.maxSeq ?? -1) + 1;
+		try {
+			await this.db.insert(eventAssets).values({
+				orgId,
+				eventId,
+				assetId: input.assetId,
+				seq: nextSeq,
+				displayName: input.displayName ?? null
+			});
+		} catch (err) {
+			if (isUniqueViolation(err)) throw new ConflictError("This asset is already linked to the event");
+			throw err;
+		}
+		return this.listEventAssets(orgId, eventId);
+	}
+	async removeEventAsset(orgId, eventId, assetId) {
+		await this.assertEvent(orgId, eventId);
+		await this.db.delete(eventAssets).where(and(eq(eventAssets.orgId, orgId), eq(eventAssets.eventId, eventId), eq(eventAssets.assetId, assetId)));
+		return this.listEventAssets(orgId, eventId);
+	}
+	async renameEventAsset(orgId, eventId, assetId, displayName) {
+		await this.assertEvent(orgId, eventId);
+		await this.db.update(eventAssets).set({ displayName }).where(and(eq(eventAssets.orgId, orgId), eq(eventAssets.eventId, eventId), eq(eventAssets.assetId, assetId)));
+		return this.listEventAssets(orgId, eventId);
+	}
+	async reorderEventAssets(orgId, eventId, assetIds) {
+		await this.assertEvent(orgId, eventId);
+		for (const [seq, assetId] of assetIds.entries()) await this.db.update(eventAssets).set({ seq }).where(and(eq(eventAssets.orgId, orgId), eq(eventAssets.eventId, eventId), eq(eventAssets.assetId, assetId)));
+		return this.listEventAssets(orgId, eventId);
+	}
 	async listBundles(orgId, query) {
 		const conditions = [eq(bundles.orgId, orgId)];
 		const search = query.search?.trim();
@@ -536,8 +690,15 @@ 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) {
+	async listCommunities(orgId, query, ids) {
+		if (ids?.length === 0) return {
+			rows: [],
+			total: 0,
+			page: query.page,
+			pageSize: query.pageSize
+		};
 		const conditions = [eq(communities.orgId, orgId)];
+		if (ids) conditions.push(inArray(communities.id, ids));
 		if (query.status) conditions.push(eq(communities.status, query.status));
 		const search = query.search?.trim();
 		if (search) {
@@ -583,9 +744,6 @@ var DrizzleContentRepository = class {
 			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({
@@ -615,29 +773,52 @@ var DrizzleContentRepository = class {
 		if (!updated) return null;
 		return this.findCommunityById(orgId, id);
 	}
-	async patchDmSettings(orgId, id, patch) {
+	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 key = and(eq(settings.orgId, orgId), eq(settings.namespace, SETTINGS_NAMESPACE), eq(settings.scopeId, id));
-		await this.tx(async (tx) => {
+		const { digest, ...dm } = input;
+		await this.patchSettings(orgId, id, digest === void 0 ? { dm } : {
+			dm,
+			digest
+		});
+		return this.findCommunityById(orgId, id);
+	}
+	async patchSettings(orgId, scopeId, patch) {
+		const key = and(eq(settings.orgId, orgId), eq(settings.namespace, SETTINGS_NAMESPACE), eq(settings.scopeId, scopeId));
+		const value = patch;
+		return 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,
+					scopeId,
 					value
 				}).onConflictDoNothing().returning();
-				if (inserted) return;
+				if (inserted) return inserted.value;
 				[existing] = await tx.select().from(settings).where(key).for("update");
-				if (!existing) throw new Error("community settings patch: row vanished mid-transaction");
+				if (!existing) throw new Error(`settings patch for ${scopeId}: row vanished mid-transaction`);
 			}
-			await tx.update(settings).set({
-				value: deepMerge(existing.value, { dm: patch }),
+			const [updated] = await tx.update(settings).set({
+				value: deepMerge(existing.value, patch),
 				updatedAt: /* @__PURE__ */ new Date()
-			}).where(key);
+			}).where(key).returning();
+			if (!updated) throw new Error(`settings patch for ${scopeId} returned no row`);
+			return updated.value;
 		});
-		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;
@@ -779,6 +960,6 @@ var DrizzleContentRepository = class {
 };
 translateDbErrors(DrizzleContentRepository);
 //#endregion
-export { DrizzleContentRepository };
+export { DrizzleContentRepository, SETTINGS_NAMESPACE };
 
 //# sourceMappingURL=content.js.map