Updating Offline Mode

components/Container.tsx

@@ -362,7 +362,8 @@ export default function Container(props: ContainerProps) {
 
 								<Link href={`/${selectedTeam?.slug}`}>
 									<button className="btn btn-ghost normal-case bg-base-100">
-										<BiHome className="text-2xl"></BiHome>Team Home
+										<BiHome className="text-2xl"></BiHome>
+										{selectedTeam?.alliance ? "Alliance Home" : "Team Home"}
 									</button>
 								</Link>
 

components/TeamCard.tsx

@@ -10,8 +10,9 @@ export default function TeamCard(props: { team: Team | undefined }) {
 			className="w-full bg-base-300 border-4 border-base-300 transition ease-in hover:border-primary"
 		>
 			<h1 className="font-semibold max-sm:text-sm">
-				{team?.league} Team <span className="text-accent">{team?.number}</span>{" "}
-				- <span className="text-primary">{team?.users.length}</span> members
+				{team?.league} {team?.alliance ? "Alliance" : "Team"}{" "}
+				<span className="text-accent">{team?.number}</span> -{" "}
+				<span className="text-primary">{team?.users.length}</span> members
 			</h1>
 		</Card>
 	);

components/stats/Picklist.tsx

@@ -20,6 +20,8 @@ import {
 const SHOW_PICKLISTS_ON_TEAM_CARDS = false;
 const SHOW_CARD_IDS = false;
 
+const api = new ClientApi();
+
 function TeamCard(props: {
 	entry: PicklistEntry;
 	draggable: boolean;
@@ -297,8 +299,6 @@ export function TeamList(props: {
 	);
 }
 
-const api = new ClientApi();
-
 export default function PicklistScreen(props: {
 	teams: number[];
 	reports: Report[];
@@ -321,10 +321,16 @@ export default function PicklistScreen(props: {
 	const teams = props.teams.map((team) => ({ number: team }));
 
 	// Save picklists
-	useEffect(
-		() => savePicklistGroup(props.picklist._id, picklists, strikethroughs, api),
-		[props.picklist._id, picklists, strikethroughs],
-	);
+	useEffect(() => {
+		if (loadingPicklists !== LoadState.Loaded) return;
+		savePicklistGroup(props.picklist._id, picklists, strikethroughs, api);
+	}, [
+		props.picklist._id,
+		picklists,
+		strikethroughs,
+		LoadState.Loaded,
+		loadingPicklists,
+	]);
 
 	const updatePicklist = useCallback(
 		(picklist: Picklist) => {

lib/MongoDB.ts

@@ -5,6 +5,8 @@ import DbInterface, {
 	WithStringOrObjectIdId,
 } from "./client/dbinterfaces/DbInterface";
 import { default as BaseMongoDbInterface } from "mongo-anywhere/MongoDbInterface";
+import CachedDbInterface from "./client/dbinterfaces/CachedDbInterface";
+import { cacheOptions } from "./client/dbinterfaces/CachedDbInterface";
 
 if (!process.env.MONGODB_URI) {
 	// Necessary to allow connections from files running outside of Next
@@ -28,10 +30,13 @@ clientPromise = global.clientPromise;
 
 export { clientPromise };
 
-export async function getDatabase(): Promise<MongoDBInterface> {
+export async function getDatabase(): Promise<DbInterface> {
 	if (!global.interface) {
 		await clientPromise;
-		const dbInterface = new MongoDBInterface(clientPromise);
+		const dbInterface = new CachedDbInterface(
+			new MongoDBInterface(clientPromise),
+			cacheOptions,
+		);
 		await dbInterface.init();
 		global.interface = dbInterface;
 

lib/ResendUtils.ts

@@ -3,15 +3,20 @@ import { Resend } from "resend";
 import { getDatabase } from "./MongoDB";
 import { User } from "./Types";
 import CollectionId from "./client/CollectionId";
-
-const resend = new Resend(process.env.SMTP_PASSWORD);
+import { ObjectId } from "bson";
 
 export interface ResendInterface {
 	createContact: (rawUser: NextAuthUser) => Promise<void>;
 	emailDevelopers: (subject: string, message: string) => void;
 }
 
 export class ResendUtils implements ResendInterface {
+	private static resend: Resend;
+
+	constructor() {
+		ResendUtils.resend ??= new Resend(process.env.SMTP_PASSWORD);
+	}
+
 	async createContact(rawUser: NextAuthUser) {
 		const user = rawUser as User;
 
@@ -26,7 +31,7 @@ export class ResendUtils implements ResendInterface {
 
 		const nameParts = user.name?.split(" ");
 
-		const res = await resend.contacts.create({
+		const res = await ResendUtils.resend.contacts.create({
 			email: user.email,
 			firstName: nameParts[0],
 			lastName: nameParts.length > 1 ? nameParts[1] : "",
@@ -41,13 +46,16 @@ export class ResendUtils implements ResendInterface {
 		}
 
 		const db = await getDatabase();
-		// Going around our own interface is a red flag, but it's 11 PM and I'm tired -Renato
-		db.db
-			?.collection(CollectionId.Users)
-			.updateOne(
-				{ email: user.email },
-				{ $set: { resendContactId: res.data.id } },
-			);
+		const id = (await db.findObject(CollectionId.Users, { email: user.email }))
+			?._id;
+		if (!id) {
+			console.error("User not found in database", user.email);
+			return;
+		}
+
+		db.updateObjectById(CollectionId.Users, new ObjectId(id), {
+			resendContactId: res.data.id,
+		});
 	}
 
 	async emailDevelopers(subject: string, message: string) {
@@ -56,7 +64,7 @@ export class ResendUtils implements ResendInterface {
 			return;
 		}
 
-		resend.emails.send({
+		ResendUtils.resend.emails.send({
 			from: "Gearbox Server <[email protected]>",
 			to: JSON.parse(process.env.DEVELOPER_EMAILS), // Environment variables are always strings, so we need to parse it
 			subject,

lib/TheBlueAlliance.ts

@@ -12,6 +12,7 @@ import {
 import { NotLinkedToTba } from "./client/ClientUtils";
 import { GameId, defaultGameId } from "./client/GameId";
 import { games } from "./games";
+import DbInterface from "./client/dbinterfaces/DbInterface";
 
 export namespace TheBlueAlliance {
 	export interface SimpleTeam {
@@ -209,7 +210,7 @@ export namespace TheBlueAlliance {
 
 	export class Interface {
 		req: Request;
-		db: Promise<MongoDBInterface>;
+		db: Promise<DbInterface>;
 
 		competitionPairings: CompetitonNameIdPair[] = [];
 

lib/Types.ts

@@ -88,6 +88,7 @@ export class Team {
 	tbaId: string | undefined;
 	number: number;
 	league: League = League.FRC;
+	alliance: boolean;
 
 	owners: string[];
 	users: string[];
@@ -109,6 +110,7 @@ export class Team {
 		tbaId: string | undefined,
 		number: number,
 		league: League = League.FRC,
+		alliance: boolean = false,
 		owners: string[] = [],
 		users: string[] = [],
 		scouters: string[] = [],
@@ -122,6 +124,7 @@ export class Team {
 		this.tbaId = tbaId;
 		this.number = number;
 		this.league = league;
+		this.alliance = alliance;
 		this.owners = owners;
 		this.users = users;
 		this.scouters = scouters;

lib/UrlResolver.ts

@@ -29,7 +29,7 @@ export interface ResolvedUrlData {
  * @param object - Any `Object` with a `_id` property
  * @returns - The same object, but with `_id` set as a string
  */
-export function SerializeDatabaseObject(object: any): any {
+export function serializeDatabaseObject(object: any): any {
 	if (!object) {
 		return null;
 	}
@@ -46,8 +46,8 @@ export function SerializeDatabaseObject(object: any): any {
 	return object;
 }
 
-export function SerializeDatabaseObjects(objectArray: any[]): any[] {
-	return objectArray.map((obj) => SerializeDatabaseObject(obj));
+export function serializeDatabaseObjects(objectArray: any[]): any[] {
+	return objectArray.map((obj) => serializeDatabaseObject(obj));
 }
 
 /**
@@ -115,10 +115,10 @@ export default async function UrlResolver(
 		// find these slugs, and convert them to a JSON safe condition
 		// if they dont exist, simply return nothing
 		const data: ResolvedUrlData = {
-			team: SerializeDatabaseObject(await promises[0]),
-			season: SerializeDatabaseObject(await promises[1]),
-			competition: SerializeDatabaseObject(await promises[2]),
-			report: SerializeDatabaseObject(await promises[3]),
+			team: serializeDatabaseObject(await promises[0]),
+			season: serializeDatabaseObject(await promises[1]),
+			competition: serializeDatabaseObject(await promises[2]),
+			report: serializeDatabaseObject(await promises[3]),
 		};
 		return data;
 	} catch (error) {

lib/api/ClientApi.ts

@@ -222,7 +222,7 @@ export default class ClientApi extends NextApiTemplate<ApiDependencies> {
 	});
 
 	createTeam = createNextRoute<
-		[string, string, number, League],
+		[string, string, number, League, boolean],
 		Team | undefined,
 		ApiDependencies,
 		void
@@ -233,7 +233,7 @@ export default class ClientApi extends NextApiTemplate<ApiDependencies> {
 			res,
 			{ db: dbPromise, resend, userPromise },
 			authData,
-			[name, tbaId, number, league],
+			[name, tbaId, number, league, alliance],
 		) => {
 			const user = (await userPromise)!;
 			const db = await dbPromise;
@@ -256,6 +256,7 @@ export default class ClientApi extends NextApiTemplate<ApiDependencies> {
 				tbaId,
 				number,
 				league,
+				alliance,
 				[user._id!.toString()],
 				[user._id!.toString()],
 				[user._id!.toString()],
@@ -2302,4 +2303,32 @@ export default class ClientApi extends NextApiTemplate<ApiDependencies> {
 			res.status(200).send(responseObj);
 		},
 	});
+
+	getCacheStats = createNextRoute<
+		[],
+		object | undefined,
+		ApiDependencies,
+		void
+	>({
+		isAuthorized: AccessLevels.IfDeveloper,
+		handler: async (req, res, {}, authData, args) => {
+			if (!global.cache) return res.status(200).send(undefined);
+			const stats = global.cache.getStats();
+			return res.status(200).send(stats);
+		},
+	});
+
+	getCachedValue = createNextRoute<
+		[string],
+		object | undefined,
+		ApiDependencies,
+		void
+	>({
+		isAuthorized: AccessLevels.IfDeveloper,
+		handler: async (req, res, {}, authData, [key]) => {
+			if (!global.cache) return res.status(500).send({ error: "No cache" });
+			const val = global.cache.get(key) as object | undefined;
+			return res.status(200).send(val);
+		},
+	});
 }

lib/client/dbinterfaces/CachedDbInterface.ts

@@ -0,0 +1,66 @@
+import { ObjectId } from "bson";
+import CollectionId, { CollectionIdToType } from "@/lib/client/CollectionId";
+import DbInterface, {
+	WithStringOrObjectIdId,
+} from "@/lib/client/dbinterfaces/DbInterface";
+import { default as BaseCachedDbInterface } from "mongo-anywhere/CachedDbInterface";
+import NodeCache from "node-cache";
+import { CacheOperation } from "mongo-anywhere/CachedDbInterface";
+
+export const cacheOptions: NodeCache.Options = {
+	stdTTL: 10 * 60,
+	useClones: false,
+};
+
+export default class CachedDbInterface
+	extends BaseCachedDbInterface<CollectionId, CollectionIdToType<CollectionId>>
+	implements DbInterface
+{
+	init(): Promise<void> {
+		return super.init(Object.values(CollectionId));
+	}
+	getTtl(operation: CacheOperation, collectionId: CollectionId): number {
+		if (operation === "count") return 3 * 60 * 60;
+
+		return cacheOptions.stdTTL!;
+	}
+	addObject<TId extends CollectionId, TObj extends CollectionIdToType<TId>>(
+		collection: TId,
+		object: WithStringOrObjectIdId<TObj>,
+	): Promise<TObj> {
+		return super.addObject(collection, object);
+	}
+	deleteObjectById(collection: CollectionId, id: ObjectId): Promise<void> {
+		return super.deleteObjectById(collection, id);
+	}
+	updateObjectById<
+		TId extends CollectionId,
+		TObj extends CollectionIdToType<TId>,
+	>(collection: TId, id: ObjectId, newValues: Partial<TObj>): Promise<void> {
+		return super.updateObjectById(collection, id, newValues);
+	}
+	findObjectById<
+		TId extends CollectionId,
+		TObj extends CollectionIdToType<TId>,
+	>(collection: TId, id: ObjectId): Promise<TObj | undefined> {
+		return super.findObjectById(collection, id);
+	}
+	findObject<TId extends CollectionId, TObj extends CollectionIdToType<TId>>(
+		collection: TId,
+		query: object,
+	): Promise<TObj | undefined> {
+		return super.findObject(collection, query);
+	}
+	findObjects<TId extends CollectionId, TObj extends CollectionIdToType<TId>>(
+		collection: TId,
+		query: object,
+	): Promise<TObj[]> {
+		return super.findObjects(collection, query);
+	}
+	countObjects(
+		collection: CollectionId,
+		query: object,
+	): Promise<number | undefined> {
+		return super.countObjects(collection, query);
+	}
+}