Add an endpoint to retrieve notes

src/routes/assignments/list.ts

@@ -125,6 +125,10 @@ export const listAssignments = new Elysia().use(HttpStatusCode()).get(
 					updates: () => ({
 						user: () => ({ username: true, displayname: true }),
 						time: true,
+						updates: () => ({
+							user: () => ({ username: true, displayname: true }),
+							time: true,
+						}),
 					}),
 					id: true,
 				};

src/routes/calendar/list.ts

@@ -11,6 +11,7 @@ import {
 	normalDateToCustom,
 	stringToNormal,
 } from "utils/dates/customAndNormal";
+import { strToDir } from "utils/db/direction";
 import { promiseResult } from "utils/errors";
 import { replaceDateDeep } from "utils/objects/transform";
 import { responseBuilder } from "utils/response";
@@ -32,8 +33,6 @@ export const listCalendar = new Elysia().use(HttpStatusCode()).get(
 		}
 		const classNames = removeDuplicates(classesResult.data).sort();
 
-		const isDescending = query.orderDirection === "desc";
-
 		const latestStart = savePredicate(
 			query.filter?.start?.latest,
 			stringToNormal,
@@ -85,7 +84,7 @@ export const listCalendar = new Elysia().use(HttpStatusCode()).get(
 					),
 					order_by: {
 						expression: orderExpression,
-						direction: isDescending ? e.DESC : e.ASC,
+						direction: strToDir(query.orderDirection),
 						empty: e.EMPTY_LAST,
 					},
 					limit: internalLimit,

src/routes/notes/index.ts

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

src/routes/notes/list.ts

@@ -0,0 +1,136 @@
+import e from "@edgedb";
+import { DATABASE_READ_FAILED } 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 { stringArraySchema } from "schemas/stringArray";
+import { removeDuplicates } from "utils/arrays/duplicates";
+import { filterTruthy } from "utils/arrays/filter";
+import { normalDateToCustom } from "utils/dates/customAndNormal";
+import { strToDir } from "utils/db/direction";
+import { promiseResult } from "utils/errors";
+import { replaceDateDeep } from "utils/objects/transform";
+import { responseBuilder } from "utils/response";
+import { split } from "utils/strings/split";
+import { surround } from "utils/strings/surround";
+
+export const listNotes = new Elysia()
+	.use(HttpStatusCode())
+	.use(auth)
+	.get(
+		"/",
+		async ({ set, httpStatus, query, auth }) => {
+			const classesResult = stringArraySchema.safeParse(
+				filterTruthy(split(query.classes)),
+			);
+			if (!classesResult.success) {
+				set.status = httpStatus.HTTP_400_BAD_REQUEST;
+				return responseBuilder("error", {
+					error: "Classes must be an array of strings",
+				});
+			}
+			const classNames = removeDuplicates(classesResult.data).sort();
+
+			const qFilter = query.filter?.query;
+
+			const dbQuery = (limit: number, offset: number) =>
+				e.select(e.Note, (n) => {
+					const internalLimit = limit === -1 ? undefined : limit;
+
+					const classMatches = e.op(
+						e.op(n.class.name, "=", e.set(...classNames)),
+						"and",
+						e.op(n.class.school.name, "=", query.school),
+					);
+
+					const queryFilter = qFilter
+						? e.op(
+								e.op(n.title, "ilike", surround(qFilter, "%")),
+								"or",
+								e.op(n.summary, "ilike", surround(qFilter, "%")),
+							)
+						: e.bool(true);
+
+					const orderExpression = {
+						title: n.title,
+						summary: n.summary,
+						"last-update": e.max(n.updates.time),
+						"first-update": e.min(n.updates.time),
+					}[query.orderKey];
+
+					return {
+						filter: e.op(classMatches, "and", queryFilter),
+						order_by: {
+							expression: orderExpression,
+							direction: strToDir(query.orderDirection),
+							empty: e.EMPTY_LAST,
+						},
+						limit: internalLimit,
+						offset,
+
+						title: true,
+						summary: true,
+						tags: () => ({
+							tag: true,
+							color: true,
+						}),
+						editScope: auth.isAuthorized,
+						priority: true,
+						updates: () => ({
+							user: () => ({ username: true, displayname: true }),
+							time: true,
+						}),
+						id: true,
+					};
+				});
+			const result = await promiseResult(() =>
+				dbQuery(query.limit, query.offset).run(client),
+			);
+
+			if (result.isError) {
+				set.status = httpStatus.HTTP_500_INTERNAL_SERVER_ERROR;
+				return DATABASE_READ_FAILED;
+			}
+
+			const formatted = result.data.map((i) =>
+				replaceDateDeep(i, normalDateToCustom),
+			);
+
+			return responseBuilder("success", {
+				message: "Successfully retrieved data",
+				data: {
+					notes: formatted,
+				},
+			});
+		},
+		{
+			query: t.Object({
+				school: t.String({ minLength: 1 }),
+				classes: t.String({ minLength: 1 }),
+
+				limit: t.Numeric({ minimum: -1, default: 15 }),
+				offset: t.Numeric({ minimum: 0, default: 0 }),
+
+				orderDirection: t.Union([t.Literal("asc"), t.Literal("desc")], {
+					default: "desc",
+				}),
+				orderKey: t.Union(
+					[
+						t.Literal("title"),
+						t.Literal("summary"),
+						t.Literal("last-update"),
+						t.Literal("first-update"),
+					],
+					{
+						default: "last-update",
+					},
+				),
+				filter: t.Optional(
+					t.ObjectString({
+						query: t.Optional(t.String()),
+					}),
+				),
+			}),
+		},
+	);

src/utils/db/direction.ts

@@ -0,0 +1,4 @@
+import e from "@edgedb";
+
+export const strToDir = (dir: "asc" | "desc") =>
+	dir === "asc" ? e.ASC : e.DESC;