taleem-kernel 1.2.0 → 1.5.0

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) {

package/src/modules/User.js

@@ -1,10 +1,12 @@
 // src/serverKernel/modules/User.js
 
 import bcrypt from "bcrypt";
+import JWT from "../utils/JWT.js";
 
 export default class User {
 	constructor(kernel) {
 		this.kernel = kernel;
+		this.jwt = new JWT(kernel);
 	}
 
 	// Queries
@@ -31,28 +33,69 @@ export default class User {
 
 	async register(data) {
 		const password = await bcrypt.hash(data.password, 10);
-		return this.kernel.db.user.create({ data: { ...data, password } });
+
+		return this.kernel.db.user.create({
+			data: { ...data, password }
+		});
 	}
 
 	async login(email, password) {
 		const user = await this.getByEmail(email);
-		if (!user) throw new Error(`User.login(): User '${email}' not found.`);
+
+		if (!user) {
+			throw new Error(`User.login(): User '${email}' not found.`);
+		}
 
 		const ok = await bcrypt.compare(password, user.password);
-		if (!ok) throw new Error(`User.login(): Invalid password.`);
 
-		return this.kernel.auth.createUserToken(user);
+		if (!ok) {
+			throw new Error(`User.login(): Invalid password.`);
+		}
+
+		return this.createToken(user);
+	}
+
+	async createToken(user) {
+		return this.jwt.sign({
+			id: user.id,
+			type: "user"
+		});
+	}
+
+	async authenticate(token) {
+		const payload = this.jwt.verify(token);
+
+		if (payload.type !== "user") {
+			throw new Error("User token required.");
+		}
+
+		const user = await this.get(payload.id);
+
+		if (!user) {
+			throw new Error("User not found.");
+		}
+
+		return user;
 	}
 
 	// CRUD
 
 	async update(id, data) {
 		const updateData = { ...data };
-		if (updateData.password) updateData.password = await bcrypt.hash(updateData.password, 10);
-		return this.kernel.db.user.update({ where: { id }, data: updateData });
+
+		if (updateData.password) {
+			updateData.password = await bcrypt.hash(updateData.password, 10);
+		}
+
+		return this.kernel.db.user.update({
+			where: { id },
+			data: updateData
+		});
 	}
 
 	async delete(id) {
-		return this.kernel.db.user.delete({ where: { id } });
+		return this.kernel.db.user.delete({
+			where: { id }
+		});
 	}
 }

package/src/utils/JWT.js

@@ -0,0 +1,31 @@
+// /home/bilal-tariq/00--TALEEM/taleem-kernel/src/utils/JWT.js
+
+import jwt from "jsonwebtoken";
+
+export default class JWT {
+
+	constructor(kernel) {
+
+		this.kernel = kernel;
+
+	}
+
+	sign(payload) {
+
+		return jwt.sign(
+			payload,
+			this.kernel.config.jwtSecret
+		);
+
+	}
+
+	verify(token) {
+
+		return jwt.verify(
+			token,
+			this.kernel.config.jwtSecret
+		);
+
+	}
+
+}

package/src/Auth.js

@@ -1,105 +0,0 @@
-///home/bilal-tariq/00--TALEEM/taleem-server/src/serverKernel/Auth.js
-
-import JWT from "./JWT.js";
-
-export default class Auth {
-
-	constructor(kernel) {
-		this.kernel = kernel;
-		this.jwt = new JWT(kernel);
-	}
-	// --------------------------------------------------
-	// Token Creation
-	// --------------------------------------------------
-	createUserToken(user) {
-
-		return this.jwt.sign({ id: user.id, type: "user" });
-
-	}
-
-	createAdminToken(admin) {
-
-		return this.jwt.sign({ id: admin.id, type: "admin" });
-
-	}
-
-	// --------------------------------------------------
-	// Authentication
-	// --------------------------------------------------
-
-	async authenticate(token) {
-
-		const { id, type } = this.verifyToken(token);
-
-		if (type === "user") return this.authenticateUser(id);
-
-		if (type === "admin") return this.authenticateAdmin(id);
-
-		this.fail("authenticate()", `Unknown identity type '${type}'.`);
-
-	}
-
-async authenticateUser(id) {
-
-	const user = await this.kernel.user.get(id);
-
-	if (!user)
-		this.fail(
-			"authenticateUser()",
-			`User '${id}' does not exist.`
-		);
-
-	return user;
-
-}
-
-async authenticateAdmin(id) {
-
-	const admin = await this.kernel.admin.get(id);
-
-	if (!admin)
-		this.fail(
-			"authenticateAdmin()",
-			`Admin '${id}' does not exist.`
-		);
-
-	return admin;
-
-}
-
-	verifyToken(token) {
-
-		try {
-
-			return this.jwt.verify(token);
-
-		}
-		catch (error) {
-
-			this.fail("verifyToken()", error.message);
-
-		}
-
-	}
-
-	// --------------------------------------------------
-	// Helpers
-	// --------------------------------------------------
-
-	fail(method, reason) {
-
-		throw new Error(
-			[
-				"",
-				"========================================",
-				"AUTHENTICATION FAILED",
-				"----------------------------------------",
-				`Method : Auth.${method}`,
-				`Reason : ${reason}`,
-				"========================================"
-			].join("\n")
-		);
-
-	}
-
-}