diff --git a/client/src/util/misc.tsx b/client/src/util/misc.tsx
index 8b77fb79..56bcea29 100644
--- a/client/src/util/misc.tsx
+++ b/client/src/util/misc.tsx
@@ -188,10 +188,13 @@ export const getByTag = <K extends keyof HTMLElementTagNameMap>(
 /* Async utilities
  */
 
-/** Make Promise sync
+/** "Make Promise sync".
  *
- * PROMISE EXECUTION STILL HAPPENS ASYNCRONOUSELY!
- * But potential errors are catched.
+ * PROMISE EXECUTION STILL HAPPENS ASYNCRONOUSELY, but catches potential errors!
+ *
+ * @example <caption> The following two statements are equivalent </caption>
+ * syncify(p);
+ * p.catch((err) => { throw err; });
  */
 export const syncify = (promise: Promise<unknown>): void => {
     promise.catch((err) => {
@@ -199,10 +202,17 @@ export const syncify = (promise: Promise<unknown>): void => {
     });
 };
 
-/** "Make async funciton sync"
+/** "Make async funciton sync".
+ *
+ * Potential errors are catched, but FUNCTION CALL STILL HAPPENS ASYNCRONOUSELY!
+ *
+ * @example <caption> The following two expressions are equivalent </caption>
+ * syncifyF(f)
+ * (...args) => { f(...args).catch((err) => {throw err;}); }
  *
- * FUNCTION CALL STILL HAPPENS ASYNCRONOUSELY!
- * But potential errors are catched.
+ * @example <caption> Example usage </caption>
+ * async function handleClick() {...}
+ * const button = <button onClick={syncifyF(handleClick)} />
  */
 export const syncifyF =
     <Args extends unknown[]>(
diff --git a/server/src/util/error-fp.ts b/server/src/util/error-fp.ts
new file mode 100644
index 00000000..823044c3
--- /dev/null
+++ b/server/src/util/error-fp.ts
@@ -0,0 +1,18 @@
+import { curry } from "lodash/fp";
+
+import { GraphQLYogaError } from "Util/error";
+import { throv } from "Util/misc";
+
+interface Assert {
+    <T, C extends T>(
+        condition: ((_: T) => _ is C) | ((_: T) => boolean),
+        message: string,
+        code: string
+    ): <U extends T>(value: U) => U & C;
+}
+export const assert: Assert = curry(
+    (cond: (_: unknown) => boolean, msg: string, code: string, val: unknown) =>
+        cond(val)
+            ? val
+            : throv(new GraphQLYogaError(msg, { extensions: { code } }))
+);
diff --git a/server/src/util/misc.ts b/server/src/util/misc.ts
index ae6b5a7e..ea873f8d 100644
--- a/server/src/util/misc.ts
+++ b/server/src/util/misc.ts
@@ -3,18 +3,20 @@ import type { CookieStore } from "@whatwg-node/cookie-store";
 import path from "node:path";
 // eslint-disable-next-line lodash-fp/use-fp
 import lodash from "lodash";
-import { curry, isNull, keys, omit, pipe, sum, values } from "lodash/fp";
+import { curry, isNull, keys, omit, sum, values } from "lodash/fp";
 import { TNullable } from "Types";
 
 export type WithCookieStore<T> = T & { cookieStore: CookieStore };
 
 export type UnPromise<P> = P extends Promise<infer T> ? T : never;
+export type Fn0<R> = () => R;
+export type Fn1<A1, R> = (a1: A1) => R;
 
 /** Function resolving paths relative project root */
 export const resolveRoot = (...pathSegments: string[]): string =>
     path.resolve(__dirname, "../../", ...pathSegments);
 
-/** Transpose a nxm matrix to a mxn matrix
+/** Transpose a nxm matrix to a mxn matrix.
  *
  *  matrix must be well-formed
  *  n and m must be greater than 0
@@ -27,9 +29,9 @@ export const transpose = <T>(matrix: T[][]): T[][] => {
     return matrix[0]!.map((_, choice) => matrix.map((vote) => vote[choice]!));
 };
 
-/** Average of an array of numbers
+/** Average of an array of numbers.
  *
- * arr length must be greater than 0
+ * `arr` must not be empty.
  *
  * @param arr the array of which to calculate the average
  */
@@ -39,116 +41,105 @@ export const average = (arr: number[]): number => {
     return sum(arr) / arr.length;
 };
 
-export function pipe1<A, R1>(a: A, f1: (a: A) => R1): R1;
-export function pipe1<A, R1, R2>(a: A, f1: (a: A) => R1, f2: (a: R1) => R2): R2;
-export function pipe1<A, R1, R2, R3>(
-    a: A,
-    f1: (a: A) => R1,
-    f2: (a: R1) => R2,
-    f3: (a: R2) => R3
-): R3;
-export function pipe1<A, R1, R2, R3, R4>(
-    a: A,
-    f1: (a: A) => R1,
-    f2: (a: R1) => R2,
-    f3: (a: R2) => R3,
-    f4: (a: R3) => R4
-): R4;
-export function pipe1<A, R1, R2, R3, R4, R5>(
-    a: A,
-    f1: (a: A) => R1,
-    f2: (a: R1) => R2,
-    f3: (a: R2) => R3,
-    f4: (a: R3) => R4,
-    f5: (a: R4) => R5
-): R5;
-export function pipe1<A, R1, R2, R3, R4, R5, R6>(
-    a: A,
-    f1: (a: A) => R1,
-    f2: (a: R1) => R2,
-    f3: (a: R2) => R3,
-    f4: (a: R3) => R4,
-    f5: (a: R4) => R5,
-    f6: (a: R5) => R6
-): R6;
-export function pipe1<A, R1, R2, R3, R4, R5, R6, R7>(
-    a: A,
-    f1: (a: A) => R1,
-    f2: (a: R1) => R2,
-    f3: (a: R2) => R3,
-    f4: (a: R3) => R4,
-    f5: (a: R4) => R5,
-    f6: (a: R5) => R6,
-    f7: (a: R6) => R7
-): R7;
-export function pipe1(
-    arg: unknown,
-    ...fs: ((_: unknown) => unknown)[]
-): unknown {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return pipe(...fs)(arg);
+interface Pipe {
+    <A, R1, R2>(f1: (_: A) => R1, f2: (_: R1) => R2): <B extends A>(v: B) => R2;
+    <A, R1, R2, R3>(f1: (_: A) => R1, f2: (_: R1) => R2, f3: (_: R2) => R3): <
+        B extends A
+    >(
+        v: B
+    ) => R3;
+    <A, R1, R2, R3, R4>(
+        f1: (_: A) => R1,
+        f2: (_: R1) => R2,
+        f3: (_: R2) => R3,
+        f4: (_: R3) => R4
+    ): <B extends A>(v: B) => R4;
+    <A, R1, R2, R3, R4, R5>(
+        f1: (_: A) => R1,
+        f2: (_: R1) => R2,
+        f3: (_: R2) => R3,
+        f4: (_: R3) => R4,
+        f5: (_: R4) => R5
+    ): <B extends A>(v: B) => R5;
+    <A, R1, R2, R3, R4, R5, R6>(
+        f1: (_: A) => R1,
+        f2: (_: R1) => R2,
+        f3: (_: R2) => R3,
+        f4: (_: R3) => R4,
+        f5: (_: R4) => R5,
+        f6: (_: R5) => R6
+    ): <B extends A>(v: B) => R6;
+    <A, R1, R2, R3, R4, R5, R6, R7>(
+        f1: (_: A) => R1,
+        f2: (_: R1) => R2,
+        f3: (_: R2) => R3,
+        f4: (_: R3) => R4,
+        f5: (_: R4) => R5,
+        f6: (_: R5) => R6,
+        f7: (_: R6) => R7
+    ): <B extends A>(v: B) => R7;
+    (...fs: ((_: unknown) => unknown)[]): (v: unknown) => unknown;
 }
+export const pipe: Pipe =
+    (...fs: ((_: unknown) => unknown)[]) =>
+    (v: unknown) =>
+        fs.reduce((res, f) => f(res), v);
 
-type MaybePromise<T> = T | Promise<T>;
-interface Pipe1Async {
-    <A, R1>(a: MaybePromise<A>, f1: (a: A) => MaybePromise<R1>): Promise<R1>;
-    <A, R1, R2>(
-        a: MaybePromise<A>,
-        f1: (a: A) => MaybePromise<R1>,
-        f2: (a: R1) => MaybePromise<R2>
-    ): Promise<R2>;
+interface Pipe1 {
+    <A, R1, R2>(a: A, f1: (_: A) => R1, f2: (_: R1) => R2): R2;
     <A, R1, R2, R3>(
-        a: MaybePromise<A>,
-        f1: (a: A) => MaybePromise<R1>,
-        f2: (a: R1) => MaybePromise<R2>,
-        f3: (a: R2) => MaybePromise<R3>
-    ): Promise<R3>;
+        a: A,
+        f1: (_: A) => R1,
+        f2: (_: R1) => R2,
+        f3: (_: R2) => R3
+    ): R3;
     <A, R1, R2, R3, R4>(
-        a: MaybePromise<A>,
-        f1: (a: A) => MaybePromise<R1>,
-        f2: (a: R1) => MaybePromise<R2>,
-        f3: (a: R2) => MaybePromise<R3>,
-        f4: (a: R3) => MaybePromise<R4>
-    ): Promise<R4>;
+        a: A,
+        f1: (_: A) => R1,
+        f2: (_: R1) => R2,
+        f3: (_: R2) => R3,
+        f4: (_: R3) => R4
+    ): R4;
     <A, R1, R2, R3, R4, R5>(
-        a: MaybePromise<A>,
-        f1: (a: A) => MaybePromise<R1>,
-        f2: (a: R1) => MaybePromise<R2>,
-        f3: (a: R2) => MaybePromise<R3>,
-        f4: (a: R3) => MaybePromise<R4>,
-        f5: (a: R4) => MaybePromise<R5>
-    ): Promise<R5>;
+        a: A,
+        f1: (_: A) => R1,
+        f2: (_: R1) => R2,
+        f3: (_: R2) => R3,
+        f4: (_: R3) => R4,
+        f5: (_: R4) => R5
+    ): R5;
     <A, R1, R2, R3, R4, R5, R6>(
-        a: MaybePromise<A>,
-        f1: (a: A) => MaybePromise<R1>,
-        f2: (a: R1) => MaybePromise<R2>,
-        f3: (a: R2) => MaybePromise<R3>,
-        f4: (a: R3) => MaybePromise<R4>,
-        f5: (a: R4) => MaybePromise<R5>,
-        f6: (a: R5) => MaybePromise<R6>
-    ): Promise<R6>;
+        a: A,
+        f1: (_: A) => R1,
+        f2: (_: R1) => R2,
+        f3: (_: R2) => R3,
+        f4: (_: R3) => R4,
+        f5: (_: R4) => R5,
+        f6: (_: R5) => R6
+    ): R6;
     <A, R1, R2, R3, R4, R5, R6, R7>(
-        a: MaybePromise<A>,
-        f1: (a: A) => MaybePromise<R1>,
-        f2: (a: R1) => MaybePromise<R2>,
-        f3: (a: R2) => MaybePromise<R3>,
-        f4: (a: R3) => MaybePromise<R4>,
-        f5: (a: R4) => MaybePromise<R5>,
-        f6: (a: R5) => MaybePromise<R6>,
-        f7: (a: R6) => MaybePromise<R7>
-    ): Promise<R7>;
-    (arg: unknown, ...fs: ((_: unknown) => unknown)[]): Promise<unknown>;
+        a: A,
+        f1: (_: A) => R1,
+        f2: (_: R1) => R2,
+        f3: (_: R2) => R3,
+        f4: (_: R3) => R4,
+        f5: (_: R4) => R5,
+        f6: (_: R5) => R6,
+        f7: (_: R6) => R7
+    ): R7;
+    (a: unknown, ...fs: ((_: unknown) => unknown)[]): unknown;
 }
-export const pipe1Async: Pipe1Async = (
+export const pipe1: Pipe1 = (
     arg: unknown,
     ...fs: ((_: unknown) => unknown)[]
-): Promise<unknown> => fs.reduce((res, f) => res.then(f), Promise.resolve(arg));
+): unknown => fs.reduce((res, f) => f(res), arg);
 
 type MapFn<From, To> = (oldValue: From) => To;
 interface MapValues {
     <
-        O extends Record<PropertyKey, unknown>,
-        FO extends { [_K in keyof Partial<O>]: MapFn<O[_K], unknown> }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        FO extends Record<PropertyKey, MapFn<any, unknown>>,
+        O extends { [_K in keyof FO]: Parameters<FO[_K]>[0] }
     >(
         fs: FO,
         o: O
@@ -156,17 +147,17 @@ interface MapValues {
         // conveniently remove readonly, since often `as const` is used for type inference
         -readonly [_K in keyof FO]: ReturnType<FO[_K]>;
     };
-    <
-        O extends Record<PropertyKey, unknown>,
-        FO extends { [_K in keyof Partial<O>]: MapFn<O[_K], unknown> }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    <FO extends Record<PropertyKey, MapFn<any, unknown>>>(fs: FO): <
+        O extends { [_K in keyof FO]: Parameters<FO[_K]>[0] }
     >(
-        fs: FO
-    ): (o: O) => { [_K in Exclude<keyof O, keyof FO>]: O[_K] } & {
+        o: O
+    ) => { [_K in Exclude<keyof O, keyof FO>]: O[_K] } & {
         // conveniently remove readonly, since often `as const` is used for type inference
         -readonly [_K in keyof FO]: ReturnType<FO[_K]>;
     };
 }
-/** Map over values of an object by key
+/** Map over values of an object by key.
  *
  * Curried usage possible.
  *
@@ -220,6 +211,17 @@ export const moveKeys: MoveKeys = curry((ks: object, o: object) => ({
     ...lodash.mapValues(ks, (k) => o[k]),
 }));
 
+interface Get {
+    <K extends PropertyKey, O extends Record<K, unknown>>(key: K, obj: O): O[K];
+    <K extends PropertyKey>(key: K): <O extends Record<K, unknown>>(
+        obj: O & Record<K, unknown>
+    ) => O[K];
+}
+/** Gets the value at `key` of `obj`. */
+// @ts-expect-error Typesafety given by interface
+// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+export const get: Get = curry((key: PropertyKey, obj: object) => obj[key]);
+
 export const forEachAsync = async <T, R>(
     arr: T[],
     callback: (val: T) => Promise<R>
@@ -239,7 +241,12 @@ export const forEachAsync = async <T, R>(
  */
 export const compute = <T>(f: () => T): T => f();
 
-/** Apply a function if value is not null */
+/** Throw an error */
+export const throv = (error: unknown): never => {
+    throw error;
+};
+
+/** Apply a function if value is not null. */
 export const mapNullableC =
     <T, U>(f: (_x: T) => U) =>
     (x: TNullable<T>): TNullable<U> =>
@@ -247,7 +254,7 @@ export const mapNullableC =
 
 /* * Haskell-style logging functions * */
 
-/** Log a value and return another  */
+/** Log a value and return another.  */
 export function log<T>(msg: unknown, x: T): T {
     // eslint-disable-next-line no-console
     console.log(msg);
@@ -259,10 +266,13 @@ export function logId<T>(x: T): T {
     return log(x, x);
 }
 
-/** Make Promise sync
+/** "Make Promise sync".
+ *
+ * PROMISE EXECUTION STILL HAPPENS ASYNCRONOUSELY, but catches potential errors!
  *
- * PROMISE EXECUTION STILL HAPPENS ASYNCRONOUSELY!
- * But potential errors are catched.
+ * @example <caption> The following two statements are equivalent </caption>
+ * syncify(p);
+ * p.catch((err) => { throw err; });
  */
 export const syncify = (promise: Promise<unknown>): void => {
     promise.catch((err) => {
@@ -270,10 +280,17 @@ export const syncify = (promise: Promise<unknown>): void => {
     });
 };
 
-/** "Make async funciton sync"
+/** "Make async funciton sync".
+ *
+ * Potential errors are catched, but FUNCTION CALL STILL HAPPENS ASYNCRONOUSELY!
+ *
+ * @example <caption> The following two expressions are equivalent </caption>
+ * syncifyF(f)
+ * (...args) => { f(...args).catch((err) => {throw err;}); }
  *
- * FUNCTION CALL STILL HAPPENS ASYNCRONOUSELY!
- * But potential errors are catched.
+ * @example <caption> Example usage </caption>
+ * async function handleClick() {...}
+ * const button = <button onClick={syncifyF(handleClick)} />
  */
 export const syncifyF =
     <Args extends unknown[]>(
diff --git a/server/src/util/promises.ts b/server/src/util/promises.ts
new file mode 100644
index 00000000..f9c6e94d
--- /dev/null
+++ b/server/src/util/promises.ts
@@ -0,0 +1,117 @@
+type MaybePromise<T> = T | Promise<T>;
+
+/**
+ * Creates a Promise that is resolved with an array of results when all of the provided Promises
+ * resolve, or rejected when any Promise is rejected.
+ * @param values An array of Promises.
+ * @returns A new Promise.
+ */
+export const all: (typeof Promise)["all"] = (values: unknown[]) =>
+    Promise.all(values);
+
+/**
+ * Creates a Promise that is resolved with an array of results when all
+ * of the provided Promises resolve or reject.
+ * @param values An array of Promises.
+ * @returns A new Promise.
+ */
+export const allSettled: (typeof Promise)["allSettled"] = (values: unknown[]) =>
+    Promise.allSettled(values);
+
+/**
+ * The any function returns a promise that is fulfilled by the first given promise to be fulfilled, or rejected with an AggregateError containing an array of rejection reasons if all of the given promises are rejected. It resolves all elements of the passed iterable to promises as it runs this algorithm.
+ * @param values An array or iterable of Promises.
+ * @returns A new Promise.
+ */
+export const any: (typeof Promise)["any"] = (values: unknown[]) =>
+    Promise.any(values);
+
+/**
+ * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+ * or rejected.
+ * @param values An array of Promises.
+ * @returns A new Promise.
+ */
+export const race: (typeof Promise)["race"] = (values: unknown[]) =>
+    Promise.race(values);
+
+/**
+ * Creates a new rejected promise for the provided reason.
+ * @param reason The reason the promise was rejected.
+ * @returns A new rejected Promise.
+ */
+export const reject: (typeof Promise)["reject"] = (reason: unknown) =>
+    Promise.reject(reason);
+
+/**
+ * Creates a new resolved promise for the provided value.
+ * @param value A promise.
+ * @returns A promise whose internal state matches the provided promise.
+ */
+export const resolve: (typeof Promise)["resolve"] = <T>(reason?: T) =>
+    Promise.resolve(reason);
+
+/**
+ * Creates a new Promise and returns it in an object, along with its resolve and reject functions.
+ * @returns An object with the properties `promise`, `resolve`, and `reject`.
+ *
+ * ```ts
+ * const { promise, resolve, reject } = Promise.withResolvers<T>();
+ * ```
+ */
+export const withResolvers: (typeof Promise)["withResolvers"] = () =>
+    Promise.withResolvers();
+
+interface Pipe1 {
+    <A, R1>(a: MaybePromise<A>, f1: (a: A) => MaybePromise<R1>): Promise<R1>;
+    <A, R1, R2>(
+        a: MaybePromise<A>,
+        f1: (a: A) => MaybePromise<R1>,
+        f2: (a: R1) => MaybePromise<R2>
+    ): Promise<R2>;
+    <A, R1, R2, R3>(
+        a: MaybePromise<A>,
+        f1: (a: A) => MaybePromise<R1>,
+        f2: (a: R1) => MaybePromise<R2>,
+        f3: (a: R2) => MaybePromise<R3>
+    ): Promise<R3>;
+    <A, R1, R2, R3, R4>(
+        a: MaybePromise<A>,
+        f1: (a: A) => MaybePromise<R1>,
+        f2: (a: R1) => MaybePromise<R2>,
+        f3: (a: R2) => MaybePromise<R3>,
+        f4: (a: R3) => MaybePromise<R4>
+    ): Promise<R4>;
+    <A, R1, R2, R3, R4, R5>(
+        a: MaybePromise<A>,
+        f1: (a: A) => MaybePromise<R1>,
+        f2: (a: R1) => MaybePromise<R2>,
+        f3: (a: R2) => MaybePromise<R3>,
+        f4: (a: R3) => MaybePromise<R4>,
+        f5: (a: R4) => MaybePromise<R5>
+    ): Promise<R5>;
+    <A, R1, R2, R3, R4, R5, R6>(
+        a: MaybePromise<A>,
+        f1: (a: A) => MaybePromise<R1>,
+        f2: (a: R1) => MaybePromise<R2>,
+        f3: (a: R2) => MaybePromise<R3>,
+        f4: (a: R3) => MaybePromise<R4>,
+        f5: (a: R4) => MaybePromise<R5>,
+        f6: (a: R5) => MaybePromise<R6>
+    ): Promise<R6>;
+    <A, R1, R2, R3, R4, R5, R6, R7>(
+        a: MaybePromise<A>,
+        f1: (a: A) => MaybePromise<R1>,
+        f2: (a: R1) => MaybePromise<R2>,
+        f3: (a: R2) => MaybePromise<R3>,
+        f4: (a: R3) => MaybePromise<R4>,
+        f5: (a: R4) => MaybePromise<R5>,
+        f6: (a: R5) => MaybePromise<R6>,
+        f7: (a: R6) => MaybePromise<R7>
+    ): Promise<R7>;
+    (arg: unknown, ...fs: ((_: unknown) => unknown)[]): Promise<unknown>;
+}
+export const pipe1: Pipe1 = (
+    arg: unknown,
+    ...fs: ((_: unknown) => unknown)[]
+): Promise<unknown> => fs.reduce((res, f) => res.then(f), Promise.resolve(arg));