Add an endpoint to create a new note

dbschema/default.esdl

@@ -146,6 +146,31 @@ module default {
 		};
 	}
 
+	scalar type EditScope extending enum<Self, Class, School>;
+
+	type Note {
+		required class: Class {
+			readonly := true;
+		};
+
+		required title: str;
+		summary: str;
+
+		multi tags: Tag {
+			on target delete allow;
+		};
+		priority: Priority;
+
+		required editScope: EditScope {
+			default := EditScope.Self;
+		};
+
+		multi updates: Change {
+			on target delete allow;
+			on source delete delete target;
+		};
+	}
+
 	type Tag {
 		required tag: str;
 		color: str;

dbschema/migrations/00019.edgeql

@@ -0,0 +1,28 @@
+CREATE MIGRATION m1mzn3ehkgkjrnujdwfxjhe5optsk3cmyqkdagwev6vq2p5a4xxbsa
+    ONTO m1xsbfzwxprtxttepfmhlwzsayxv3keyigzrfa2o2zk3g4zttajubq
+{
+  ALTER TYPE default::Calendar {
+      ALTER LINK tags {
+          ON TARGET DELETE ALLOW;
+      };
+  };
+  CREATE SCALAR TYPE default::EditScope EXTENDING enum<Self, Class, School>;
+  CREATE TYPE default::Note {
+      CREATE REQUIRED LINK class: default::Class {
+          SET readonly := true;
+      };
+      CREATE MULTI LINK tags: default::Tag {
+          ON TARGET DELETE ALLOW;
+      };
+      CREATE MULTI LINK updates: default::Change {
+          ON SOURCE DELETE DELETE TARGET;
+          ON TARGET DELETE ALLOW;
+      };
+      CREATE PROPERTY editScope: default::EditScope {
+          SET default := (default::EditScope.Self);
+      };
+      CREATE PROPERTY priority: default::Priority;
+      CREATE PROPERTY summary: std::str;
+      CREATE REQUIRED PROPERTY title: std::str;
+  };
+};

src/index.ts

@@ -9,6 +9,7 @@ import { registerRouter } from "routes/auth/register";
 import { calendarRouter } from "routes/calendar";
 import { classRouter } from "routes/classes";
 import { moderationRouter } from "routes/moderation";
+import { noteRouter } from "routes/notes";
 import { schoolRouter } from "routes/school";
 import { tagRouter } from "routes/tags";
 import { deleteUser } from "routes/user/delete";
@@ -26,6 +27,7 @@ const app = new Elysia()
 	.use(assignmentsRouter)
 	.use(calendarRouter)
 	.use(tagRouter)
+	.use(noteRouter)
 	.get(
 		"/",
 		() => ({

src/routes/notes/create.ts

@@ -0,0 +1,83 @@
+import e from "@edgedb";
+import { DATABASE_WRITE_FAILED, UNAUTHORIZED } from "constants/responses";
+import Elysia, { t } from "elysia";
+import { HttpStatusCode } from "elysia-http-status-code";
+import { client } from "index";
+import { auth } from "plugins/auth";
+import { fallback } from "utils/arrays/fallback";
+import { promiseResult } from "utils/errors";
+import { usersClassBySchoolAndName } from "utils/queries/class";
+import { userByUsername } from "utils/queries/user";
+import { responseBuilder } from "utils/response";
+
+export const createNote = new Elysia()
+	.use(auth)
+	.use(HttpStatusCode())
+	.post(
+		"/",
+		async ({ set, httpStatus, auth, body }) => {
+			if (!auth.isAuthorized) {
+				set.status = httpStatus.HTTP_401_UNAUTHORIZED;
+				return UNAUTHORIZED;
+			}
+
+			const query = e.insert(e.Note, {
+				title: body.title,
+				class: usersClassBySchoolAndName({
+					schoolName: body.school,
+					className: body.class,
+					username: auth.username,
+				}),
+
+				summary: body.summary,
+				priority: body.priority,
+				tags: e.select(e.Tag, (t) => ({
+					filter: e.op(
+						e.op(
+							e.op(t.class.name, "=", body.class),
+							"and",
+							e.op(t.class.school.name, "=", body.school),
+						),
+						"and",
+						e.op(t.tag, "in", e.set(...fallback(body.tags || [], [""]))),
+					),
+				})),
+				editScope: body.editScope,
+
+				updates: e.insert(e.Change, { user: userByUsername(auth.username) }),
+			});
+			const result = await promiseResult(() => query.run(client));
+
+			if (result.isError) {
+				set.status = httpStatus.HTTP_500_INTERNAL_SERVER_ERROR;
+				return DATABASE_WRITE_FAILED;
+			}
+
+			set.status = httpStatus.HTTP_201_CREATED;
+			return responseBuilder("success", {
+				message: "Successfully created note",
+				data: null,
+			});
+		},
+		{
+			body: t.Object({
+				class: t.String({ minLength: 1 }),
+				school: t.String({ minLength: 1 }),
+				title: t.String({ minLength: 1 }),
+				summary: t.Optional(t.String({ minLength: 1 })),
+				tags: t.Optional(t.Array(t.String({ minLength: 1 }))),
+				priority: t.Optional(
+					t.Union([
+						t.Literal("Critical"),
+						t.Literal("High"),
+						t.Literal("Medium"),
+						t.Literal("Low"),
+						t.Literal("Minimal"),
+					]),
+				),
+				editScope: t.Optional(
+					t.Union([t.Literal("Self"), t.Literal("Class"), t.Literal("School")]),
+				),
+			}),
+		},
+	);

src/routes/notes/index.ts

@@ -0,0 +1,4 @@
+import Elysia from "elysia";
+import { createNote } from "./create";
+
+export const noteRouter = new Elysia({ prefix: "/notes" }).use(createNote);

src/utils/queries/class.ts

@@ -5,6 +5,10 @@ interface ClassBySchoolAndNameProps {
 	className: string;
 }
 
+type UsersClassBySchoolAndNameProps = ClassBySchoolAndNameProps & {
+	username: string;
+};
+
 export const classBySchoolAndName = ({
 	schoolName,
 	className,
@@ -17,3 +21,19 @@ export const classBySchoolAndName = ({
 		),
 	}));
 };
+
+export const usersClassBySchoolAndName = (
+	props: UsersClassBySchoolAndNameProps,
+) => {
+	return e.select(e.Class, (c) => ({
+		filter_single: e.op(
+			e.op(
+				e.op(c.name, "=", props.className),
+				"and",
+				e.op(c.school.name, "=", props.schoolName),
+			),
+			"and",
+			e.op(props.username, "in", c.students.username),
+		),
+	}));
+};

src/utils/queries/user.ts

@@ -0,0 +1,6 @@
+import e from "@edgedb";
+
+export const userByUsername = (username: string) =>
+	e.select(e.User, (u) => ({
+		filter_single: e.op(u.username, "=", username),
+	}));