taleem-kernel 1.0.0

package/src/modules/Communication.js

@@ -0,0 +1,116 @@
+export default class Communication {
+
+	constructor(kernel) {
+		this.kernel = kernel;
+	}
+
+	async list(filters = {}) {
+		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)
+			};
+		}
+
+		if (filters.librarySlug) where.librarySlug = filters.librarySlug;
+		if (filters.userId) where.userId = filters.userId;
+
+		if (filters.unanswered) {
+			where.OR = [
+				{ authorResponse: null },
+				{ authorResponse: "" }
+			];
+		}
+
+		return this.kernel.db.communication.findMany({
+			where,
+			include: { user: true },
+			orderBy: { createdAt: "desc" }
+		});
+	}
+
+	async get(id) {
+		const item = await this.kernel.db.communication.findUnique({
+			where: { id },
+			include: { user: 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) {
+		return this.kernel.db.communication.create({ data });
+	}
+
+	async update(id, data) {
+		return this.kernel.db.communication.update({
+			where: { id },
+			data
+		});
+	}
+
+	async delete(id) {
+		return this.kernel.db.communication.delete({
+			where: { id }
+		});
+	}
+
+	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
+		}));
+	}
+
+	async countUserOpenQuestions(userId) {
+		return this.kernel.db.communication.count({
+			where: {
+				userId,
+				OR: [
+					{ authorResponse: null },
+					{ authorResponse: "" }
+				]
+			}
+		});
+	}
+}

package/src/modules/Course.js

@@ -0,0 +1,26 @@
+export default class Course {
+	constructor(kernel) { this.kernel = kernel; }
+
+	async list(filters = {}) {
+		const where = {};
+		if (filters.access) where.access = filters.access;
+		return this.kernel.db.course.findMany({ where });
+	}
+
+	async get(slug) {
+		return this.kernel.db.course.findUnique({ where: { slug } });
+	}
+
+	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) {
+		return this.kernel.db.course.delete({ where: { slug } });
+	}
+
+}

package/src/modules/Image.js

@@ -0,0 +1,48 @@
+
+export default class Image {
+
+	constructor(kernel) {
+		this.kernel = kernel;
+	}
+
+	// --------------------------------------------------
+	// Queries
+	// --------------------------------------------------
+
+	async list() {
+
+		return this.kernel.db.image.findMany({
+
+			orderBy: {
+				createdAt: "desc"
+			}
+
+		});
+
+	}
+
+	async get(id) {
+
+		return this.kernel.db.image.findUnique({
+
+			where: { id }
+
+		});
+
+	}
+
+	// --------------------------------------------------
+	// Create
+	// --------------------------------------------------
+
+	async create(data) {
+
+		return this.kernel.db.image.create({
+
+			data
+
+		});
+
+	}
+
+}

package/src/modules/Library.js

@@ -0,0 +1,59 @@
+export default class Library {
+	constructor(kernel) { this.kernel = kernel; }
+
+	async list(filters = {}) {
+		const where = {};
+		if (filters.type) where.type = filters.type;
+		if (filters.courseSlug) where.courseSlug = filters.courseSlug;
+		if (filters.groupSlug) where.groupSlug = filters.groupSlug;
+
+		return this.kernel.db.library.findMany({
+			where,
+			select: {
+				slug: true,
+				title: true,
+				description: true,
+				thumbnail: true,
+				type: true,
+				courseSlug: true,
+				groupSlug: true,
+				sortOrder: true,
+				allowCommunication: true,
+				createdAt: true,
+				updatedAt: true
+			},
+			orderBy: { sortOrder: "asc" }
+		});
+	}
+
+	async listByCourse(courseSlug) {
+		return this.list({ courseSlug });
+	}
+
+	async listByGroup(courseSlug, groupSlug) {
+		return this.list({ courseSlug, groupSlug });
+	}
+
+	async get(slug) {
+		return this.kernel.db.library.findUnique({
+			where: { slug }
+		});
+	}
+
+	async create(data) {
+		return this.kernel.db.library.create({ data });
+	}
+
+	async update(slug, data) {
+		return this.kernel.db.library.update({
+			where: { slug },
+			data
+		});
+	}
+
+	async delete(slug) {
+		return this.kernel.db.library.delete({
+			where: { slug }
+		});
+	}
+}

package/src/modules/Subscription.js

@@ -0,0 +1,97 @@
+// src/serverKernel/modules/Subscription.js
+
+export default class Subscription {
+
+	constructor(kernel) {
+		this.kernel = kernel;
+	}
+
+	// --------------------------------------------------
+	// Queries
+	// --------------------------------------------------
+
+	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
+		});
+
+	}
+
+	async get(id) {
+
+		return this.kernel.db.subscription.findUnique({
+			where: { id }
+		});
+
+	}
+
+	// --------------------------------------------------
+	// CRUD
+	// --------------------------------------------------
+
+	async create(data) {
+
+		return this.kernel.db.subscription.create({
+			data
+		});
+
+	}
+
+	async update(id, data) {
+
+		return this.kernel.db.subscription.update({
+			where: { id },
+			data
+		});
+
+	}
+
+	async delete(id) {
+
+		return this.kernel.db.subscription.delete({
+			where: { id }
+		});
+
+	}
+
+	// --------------------------------------------------
+	// Utilities
+	// --------------------------------------------------
+
+	async authorize(userId, courseId) {
+  debugger;
+		const now = new Date();
+
+		const subscription = await this.kernel.db.subscription.findFirst({
+
+			where: {
+				userId,
+				courseId,
+				startsAt: { lte: now },
+				endsAt: { gte: now }
+			}
+
+		});
+
+		if (!subscription) {
+			throw new Error(
+				`User "${userId}" does not have an active subscription for course "${courseId}".`
+			);
+		}
+
+		return subscription;
+
+	}
+
+}

package/src/modules/Svg.js

@@ -0,0 +1,59 @@
+export default class Svg {
+
+	constructor(kernel) {
+		this.kernel = kernel;
+	}
+
+	async create(data) {
+
+		return this.kernel.db.svg.create({
+			data: {
+				slug: data.slug,
+				title: data.title,
+				body: data.body,
+				tags: data.tags ?? "[]"
+			}
+		});
+
+	}
+
+	async get(slug) {
+
+		return this.kernel.db.svg.findUnique({
+			where: { slug }
+		});
+
+	}
+
+	async list() {
+
+		return this.kernel.db.svg.findMany({
+			orderBy: {
+				title: "asc"
+			}
+		});
+
+	}
+
+	async update(slug, data) {
+
+		return this.kernel.db.svg.update({
+			where: { slug },
+			data: {
+				title: data.title,
+				body: data.body,
+				tags: data.tags
+			}
+		});
+
+	}
+
+	async delete(slug) {
+
+		return this.kernel.db.svg.delete({
+			where: { slug }
+		});
+
+	}
+
+}

package/src/modules/User.js

@@ -0,0 +1,117 @@
+// src/serverKernel/modules/User.js
+
+import bcrypt from "bcrypt";
+
+export default class User {
+
+	constructor(kernel) {
+		this.kernel = kernel;
+	}
+
+	// --------------------------------------------------
+	// Queries
+	// --------------------------------------------------
+
+	async list() {
+
+		return this.kernel.db.user.findMany();
+
+	}
+
+	async get(id) {
+
+		return this.kernel.db.user.findUnique({
+			where: { id }
+		});
+
+	}
+
+	async getByEmail(email) {
+
+		return this.kernel.db.user.findUnique({
+			where: { email }
+		});
+
+	}
+
+	async emailToId(email) {
+
+	const user = await this.getByEmail(email);
+
+	if (!user) {
+		throw new Error(`User '${email}' not found.`);
+	}
+
+	return user.id;
+
+}
+	// --------------------------------------------------
+	// Authentication
+	// --------------------------------------------------
+
+	async register(data) {
+
+		const password = await bcrypt.hash(data.password, 10);
+
+		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.`);
+		}
+
+		const ok = await bcrypt.compare(password, user.password);
+
+		if (!ok) {
+			throw new Error(`User.login(): Invalid password.`);
+		}
+
+		return this.kernel.auth.createUserToken(user);
+
+	}
+
+	// --------------------------------------------------
+	// CRUD
+	// --------------------------------------------------
+
+	async update(id, data) {
+
+		if (data.password) {
+
+			data.password = await bcrypt.hash(data.password, 10);
+
+		}
+
+		return this.kernel.db.user.update({
+
+			where: { id },
+
+			data
+
+		});
+
+	}
+
+	async delete(id) {
+
+		return this.kernel.db.user.delete({
+
+			where: { id }
+
+		});
+
+	}
+
+}

package/tests/admin.test.js

@@ -0,0 +1,52 @@
+import { describe, it, expect, afterAll } from "vitest";
+import kernel from "../src/ServerKernel.js";
+
+const email = "bilal@taleem.help";
+
+describe("Admin", () => {
+	it("gets admin by email", async () => {
+		const admin = await kernel.admin.get(email);
+
+		expect(admin).toBeTruthy();
+		expect(admin.email).toBe(email);
+		expect(admin.isActive).toBe(true);
+	});
+
+	it("lists active admins", async () => {
+		const admins = await kernel.admin.list({ isActive: true });
+
+		expect(Array.isArray(admins)).toBe(true);
+		expect(admins.some(admin => admin.email === email)).toBe(true);
+	});
+
+	it("checks course authorization", async () => {
+		expect(
+			await kernel.admin.isAdmin(email, "fbise9math")
+		).toBe(true);
+
+		expect(
+			await kernel.admin.isAdmin(email, "blog")
+		).toBe(true);
+
+		expect(
+			await kernel.admin.isAdmin(email, "fbise9mathQuickRef")
+		).toBe(true);
+
+		expect(
+			await kernel.admin.isAdmin(email, "does-not-exist")
+		).toBe(false);
+	});
+
+	it("returns false for an unknown admin", async () => {
+		expect(
+			await kernel.admin.isAdmin(
+				"unknown@example.com",
+				"fbise9math"
+			)
+		).toBe(false);
+	});
+
+	afterAll(async () => {
+		await kernel.shutdown();
+	});
+});

package/tests/course.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, afterAll } from "vitest";
+import kernel from "../src/ServerKernel.js";
+
+describe("Course", () => {
+	let testSlug;
+
+	it("lists courses", async () => {
+		const courses = await kernel.course.list();
+		expect(Array.isArray(courses)).toBe(true);
+	});
+
+	it("gets a course by slug", async () => {
+		const courses = await kernel.course.list();
+		expect(courses.length).toBeGreaterThan(0);
+
+		const course = await kernel.course.get(courses[0].slug);
+
+		expect(course).toBeTruthy();
+		expect(course.slug).toBe(courses[0].slug);
+	});
+
+	it("filters courses by access", async () => {
+		const courses = await kernel.course.list({ access: "OPEN" });
+
+		expect(Array.isArray(courses)).toBe(true);
+
+		for (const course of courses) {
+			expect(course.access).toBe("OPEN");
+		}
+	});
+
+	it("creates, updates and deletes a course", async () => {
+		testSlug = "__kernel-test-course__";
+
+		await kernel.course.create({
+			slug: testSlug,
+			title: "Kernel Test Course",
+			description: "Temporary test course",
+			access: "OPEN"
+		});
+
+		let course = await kernel.course.get(testSlug);
+		expect(course).toBeTruthy();
+		expect(course.title).toBe("Kernel Test Course");
+
+		await kernel.course.update(testSlug, {
+			title: "Updated Kernel Test Course"
+		});
+
+		course = await kernel.course.get(testSlug);
+		expect(course.title).toBe("Updated Kernel Test Course");
+
+		await kernel.course.delete(testSlug);
+
+		course = await kernel.course.get(testSlug);
+		expect(course).toBeNull();
+
+		testSlug = null;
+	});
+
+	afterAll(async () => {
+		if (testSlug) {
+			await kernel.course.delete(testSlug).catch(() => {});
+		}
+
+		await kernel.shutdown();
+	});
+});

package/tests/kernel.test.js

@@ -0,0 +1,12 @@
+import { describe, it, expect, afterAll } from "vitest";
+import kernel from "../src/ServerKernel.js";
+
+describe("Taleem Kernel", () => {
+	it("starts and connects to Prisma", async () => {
+		await expect(kernel.db.$queryRaw`SELECT 1`).resolves.toBeDefined();
+	});
+
+	afterAll(async () => {
+		await kernel.shutdown();
+	});
+});

package/tests/library.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect, afterAll } from "vitest";
+import kernel from "../src/ServerKernel.js";
+
+describe("Library", () => {
+	it("lists library content", async () => {
+		const items = await kernel.library.list();
+		expect(Array.isArray(items)).toBe(true);
+	});
+
+	it("gets a library item by slug", async () => {
+		const items = await kernel.library.list();
+		expect(items.length).toBeGreaterThan(0);
+
+		const item = await kernel.library.get(items[0].slug);
+
+		expect(item).toBeTruthy();
+		expect(item.slug).toBe(items[0].slug);
+	});
+
+	afterAll(async () => {
+		await kernel.shutdown();
+	});
+});