taleem-kernel 1.3.0 → 1.5.0

package/src/modules/Communication.js

@@ -8,18 +8,12 @@ export default class Communication {
 		const where = {};
 
 		if (filters.courseSlug) {
-			const items = await this.kernel.db.library.findMany({
-				where: { courseSlug: filters.courseSlug },
-				select: { slug: true }
-			});
-
-			where.librarySlug = {
-				in: items.map(item => item.slug)
-			};
+			where.library = { courseSlug: filters.courseSlug };
 		}
 
 		if (filters.librarySlug) where.librarySlug = filters.librarySlug;
 		if (filters.userId) where.userId = filters.userId;
+		if (filters.initiator) where.initiator = filters.initiator;
 
 		if (filters.unanswered) {
 			where.OR = [
@@ -30,35 +24,20 @@ export default class Communication {
 
 		return this.kernel.db.communication.findMany({
 			where,
-			include: { user: true },
+			include: { user: true, library: true },
 			orderBy: { createdAt: "desc" }
 		});
 	}
 
 	async get(id) {
-		const item = await this.kernel.db.communication.findUnique({
+		return this.kernel.db.communication.findUnique({
 			where: { id },
-			include: { user: true }
+			include: { user: true, library: true }
 		});
-
-		if (!item) return null;
-
-		const library = await this.kernel.db.library.findUnique({
-			where: { slug: item.librarySlug },
-			select: {
-				slug: true,
-				title: true,
-				courseSlug: true
-			}
-		});
-
-		return {
-			...item,
-			library
-		};
 	}
 
 	async create(data) {
+		// throws if librarySlug doesn't resolve to an existing Library row
 		return this.kernel.db.communication.create({ data });
 	}
 
@@ -76,30 +55,7 @@ export default class Communication {
 	}
 
 	async listUnanswered(courseSlug) {
-		const items = await this.list({
-			courseSlug,
-			unanswered: true
-		});
-
-		const slugs = [...new Set(items.map(item => item.librarySlug))];
-
-		const libraries = await this.kernel.db.library.findMany({
-			where: { slug: { in: slugs } },
-			select: {
-				slug: true,
-				title: true,
-				courseSlug: true
-			}
-		});
-
-		const map = new Map(
-			libraries.map(item => [item.slug, item])
-		);
-
-		return items.map(item => ({
-			...item,
-			library: map.get(item.librarySlug) || null
-		}));
+		return this.list({ courseSlug, unanswered: true });
 	}
 
 	async countUserOpenQuestions(userId) {

package/src/modules/Course.js

@@ -4,51 +4,44 @@ export default class Course {
 	async list(filters = {}) {
 		const where = {};
 		if (filters.access) where.access = filters.access;
+		if (filters.isActive !== undefined) where.isActive = filters.isActive;
 		return this.kernel.db.course.findMany({ where });
 	}
+
 	async get(slug) {
 		return this.kernel.db.course.findUnique({ where: { slug } });
 	}
-	async getGroups(courseSlug) {
-		return this.kernel.db.group.findMany({
-			where: { courseSlug },
-			orderBy: { id: 'asc' }
-		});
-	}
-	async getGroup(courseSlug, groupSlug) {
-		return this.kernel.db.group.findUnique({
-			where: {
-				courseSlug_slug: { courseSlug, slug: groupSlug }
-			}
-		});
-	}
-	async getGroupItems(courseSlug, groupSlug) {
-		const group = await this.getGroup(courseSlug, groupSlug);
-		return group?.items ?? [];
-	}
-	async wipe() {
-	await this.kernel.db.group.deleteMany();
-	await this.kernel.db.course.deleteMany();
-	}
-	async seed(course) {
-		const { groupings = [], ...courseData } = course;
-
-		const created = await this.kernel.db.course.create({
-			data: courseData
-		});
-
-		for (const group of groupings) {
-			await this.kernel.db.group.create({
-				data: {
-					courseSlug: created.slug,
-					slug: group.slug,
-					title: group.title,
-					thumbnail: group.thumbnail ?? null,
-					items: group.items ?? []
-				}
-			});
-		}
-
-		return created;
+
+	async create(data) {
+		return this.kernel.db.course.create({ data });
+	}
+
+	async update(slug, data) {
+		return this.kernel.db.course.update({ where: { slug }, data });
+	}
+
+	async delete(slug) {
+		// throws if any Group or Subscription still references this course
+		return this.kernel.db.course.delete({ where: { slug } });
+	}
+
+	async authorize(userId, courseSlug) {
+	const course = await this.get(courseSlug);
+	if (!course) throw new Error(`Course "${courseSlug}" not found.`);
+
+	if (course.access === "OPEN") return true;
+
+	if (course.access === "MEMBERS") {
+		if (!userId) throw new Error("Login required for this course.");
+		return true;
+	}
+
+	if (course.access === "SUBSCRIPTION") {
+		if (!userId) throw new Error("Login required for this course.");
+		await this.kernel.subscription.authorize(userId, courseSlug);
+		return true;
+	}
+
+	throw new Error(`Unknown access level "${course.access}".`);
 	}
 }

package/src/modules/Group.js

@@ -0,0 +1,48 @@
+export default class Group {
+	constructor(kernel) { this.kernel = kernel; }
+
+	async list(filters = {}) {
+		const where = {};
+		if (filters.courseSlug) where.courseSlug = filters.courseSlug;
+
+		return this.kernel.db.group.findMany({
+			where,
+			orderBy: { id: "asc" }
+		});
+	}
+
+	async listByCourse(courseSlug) {
+		return this.list({ courseSlug });
+	}
+
+	async get(courseSlug, slug) {
+		return this.kernel.db.group.findUnique({
+			where: {
+				courseSlug_slug: { courseSlug, slug }
+			}
+		});
+	}
+
+	async create(data) {
+		// throws if data.courseSlug doesn't resolve to an existing Course
+		return this.kernel.db.group.create({ data });
+	}
+
+	async update(courseSlug, slug, data) {
+		return this.kernel.db.group.update({
+			where: {
+				courseSlug_slug: { courseSlug, slug }
+			},
+			data
+		});
+	}
+
+	async delete(courseSlug, slug) {
+		// throws if any Library rows still reference this group (Restrict)
+		return this.kernel.db.group.delete({
+			where: {
+				courseSlug_slug: { courseSlug, slug }
+			}
+		});
+	}
+}

package/src/modules/Library.js

@@ -1,12 +1,17 @@
+const PUBLIC_STATUS = "PUBLISHED";
+
 export default class Library {
 	constructor(kernel) { this.kernel = kernel; }
 
-	async list(filters = {}) {
+	async list(filters = {}, { includeUnpublished = false } = {}) {
 		const where = {};
 		if (filters.type) where.type = filters.type;
 		if (filters.courseSlug) where.courseSlug = filters.courseSlug;
 		if (filters.groupSlug) where.groupSlug = filters.groupSlug;
 
+		if (!includeUnpublished) where.status = PUBLIC_STATUS;
+		else if (filters.status) where.status = filters.status;
+
 		return this.kernel.db.library.findMany({
 			where,
 			select: {
@@ -15,6 +20,7 @@ export default class Library {
 				description: true,
 				thumbnail: true,
 				type: true,
+				status: true,
 				courseSlug: true,
 				groupSlug: true,
 				sortOrder: true,
@@ -26,17 +32,20 @@ export default class Library {
 		});
 	}
 
-	async listByCourse(courseSlug) {
-		return this.list({ courseSlug });
+	async listByCourse(courseSlug, opts) {
+		return this.list({ courseSlug }, opts);
 	}
 
-	async listByGroup(courseSlug, groupSlug) {
-		return this.list({ courseSlug, groupSlug });
+	async listByGroup(courseSlug, groupSlug, opts) {
+		return this.list({ courseSlug, groupSlug }, opts);
 	}
 
-	async get(slug) {
+	async get(slug, { includeUnpublished = false } = {}) {
 		return this.kernel.db.library.findUnique({
-			where: { slug }
+			where: {
+				slug,
+				...(includeUnpublished ? {} : { status: PUBLIC_STATUS })
+			}
 		});
 	}
 
@@ -52,11 +61,13 @@ export default class Library {
 	}
 
 	async delete(slug) {
+		// throws if Communication rows still reference this slug (Restrict)
 		return this.kernel.db.library.delete({
 			where: { slug }
 		});
 	}
-		async createFromSlot(slug, courseSlug, groupSlug, type) {
+
+	async createFromSlot(slug, courseSlug, groupSlug, type) {
 		return this.create({
 			slug,
 			courseSlug,
@@ -65,4 +76,5 @@ export default class Library {
 			title: slug
 		});
 	}
+	
 }

package/src/modules/Subscription.js

@@ -1,97 +1,48 @@
-// src/serverKernel/modules/Subscription.js
-
 export default class Subscription {
-
-	constructor(kernel) {
-		this.kernel = kernel;
-	}
-
-	// --------------------------------------------------
-	// Queries
-	// --------------------------------------------------
+	constructor(kernel) { this.kernel = kernel; }
 
 	async list(filters = {}) {
-
 		const where = {};
-
-		if (filters.userId) {
-			where.userId = filters.userId;
-		}
-
-		if (filters.courseId) {
-			where.courseId = filters.courseId;
-		}
-
-		return this.kernel.db.subscription.findMany({
-			where
-		});
-
+		if (filters.userId) where.userId = filters.userId;
+		if (filters.courseSlug) where.courseSlug = filters.courseSlug;
+		return this.kernel.db.subscription.findMany({ where });
 	}
 
 	async get(id) {
-
-		return this.kernel.db.subscription.findUnique({
-			where: { id }
-		});
-
+		return this.kernel.db.subscription.findUnique({ where: { id } });
 	}
 
-	// --------------------------------------------------
-	// CRUD
-	// --------------------------------------------------
-
 	async create(data) {
-
-		return this.kernel.db.subscription.create({
-			data
-		});
-
+		// throws if courseSlug doesn't resolve to an existing Course
+		return this.kernel.db.subscription.create({ data });
 	}
 
 	async update(id, data) {
-
-		return this.kernel.db.subscription.update({
-			where: { id },
-			data
-		});
-
+		return this.kernel.db.subscription.update({ where: { id }, data });
 	}
 
 	async delete(id) {
-
-		return this.kernel.db.subscription.delete({
-			where: { id }
-		});
-
+		return this.kernel.db.subscription.delete({ where: { id } });
 	}
 
-	// --------------------------------------------------
-	// Utilities
-	// --------------------------------------------------
-
-	async authorize(userId, courseId) {
-  debugger;
+	async authorize(userId, courseSlug) {
 		const now = new Date();
 
 		const subscription = await this.kernel.db.subscription.findFirst({
-
 			where: {
 				userId,
-				courseId,
+				courseSlug,
 				startsAt: { lte: now },
 				endsAt: { gte: now }
 			}
-
 		});
 
 		if (!subscription) {
 			throw new Error(
-				`User "${userId}" does not have an active subscription for course "${courseId}".`
+				`User "${userId}" does not have an active subscription for course "${courseSlug}".`
 			);
 		}
 
 		return subscription;
-
 	}
-
 }

package/src/modules/Svg.js

@@ -1,12 +1,8 @@
-// src/serverKernel/modules/Svg.js
-
 export default class Svg {
 	constructor(kernel) { this.kernel = kernel; }
 
 	async list() {
-		return this.kernel.db.svg.findMany({
-			orderBy: { title: "asc" }
-		});
+		return this.kernel.db.svg.findMany({ orderBy: { title: "asc" } });
 	}
 
 	async get(slug) {
@@ -14,25 +10,11 @@ export default class Svg {
 	}
 
 	async create(data) {
-		return this.kernel.db.svg.create({
-			data: {
-				slug: data.slug,
-				title: data.title,
-				body: data.body,
-				tags: data.tags ?? "[]"
-			}
-		});
+		return this.kernel.db.svg.create({ data });
 	}
 
 	async update(slug, data) {
-		return this.kernel.db.svg.update({
-			where: { slug },
-			data: {
-				title: data.title,
-				body: data.body,
-				tags: data.tags
-			}
-		});
+		return this.kernel.db.svg.update({ where: { slug }, data });
 	}
 
 	async delete(slug) {