Unified db access

components/Banner.tsx

@@ -1,6 +1,16 @@
+import MiniMongoInterface from "@/lib/client/MiniMongoInterface";
+import { useEffect } from "react";
 import { FaDiscord } from "react-icons/fa";
 
 export default function Banner(props: { children: React.ReactNode }) {
+  useEffect(() => {
+    console.log("Instantiating MiniMongoInterface...");
+    const db = new MiniMongoInterface();
+    console.log("Initializing MiniMongoInterface...");
+    db.init();
+    console.log("MiniMongoInterface initialized.");
+  }, []);
+
   return (
     <div
       role="alert"

lib/API.ts

@@ -1,5 +1,5 @@
 import { NextApiRequest, NextApiResponse } from "next";
-import { Collections, getDatabase, MongoDBInterface } from "./MongoDB";
+import { getDatabase, MongoDBInterface } from "./MongoDB";
 import { TheBlueAlliance } from "./TheBlueAlliance";
 import {
   Competition,
@@ -31,6 +31,7 @@ import { xpToLevel } from "./Xp";
 import { games } from "./games";
 import { GameId } from "./client/GameId";
 import { TheOrangeAlliance } from "./TheOrangeAlliance";
+import Collections from "./client/Collections";
 
 export namespace API {
   export const GearboxHeader = "gearbox-auth";
@@ -768,10 +769,10 @@ export namespace API {
         new ObjectId(data.compId)
       );
       const matches = await db.findObjects<Match>(Collections.Matches, {
-        _id: { $in: comp.matches.map((matchId) => new ObjectId(matchId)) },
+        _id: { $in: comp.matches },
       });
       const allReports = await db.findObjects<Report>(Collections.Reports, {
-        match: { $in: matches.map((match) => match?._id?.toString()) },
+        match: { $in: matches.map((match) => match?._id?.toString() ?? "") },
       });
       const reports = allReports.filter((report) => report.submitted);
 
@@ -898,7 +899,7 @@ export namespace API {
       }).then((r) => quantitativeReports.push(...r)));
 
       promises.push(db.findObjects<Pitreport>(Collections.Pitreports, {
-        _id: { $in: comp.pitReports.map((id) => new ObjectId(id)) },
+        _id: { $in: comp.pitReports },
         submitted: true
       }).then((r) => pitReports.push(...r)));
 
@@ -948,7 +949,7 @@ export namespace API {
         submitter: data.userId,
         submitted: match.subjectiveScouter === data.userId 
           ? SubjectiveReportSubmissionType.ByAssignedScouter
-          : team.subjectiveScouters.includes(data.userId)
+          : team?.subjectiveScouters.includes(data.userId)
             ? SubjectiveReportSubmissionType.BySubjectiveScouter
             : SubjectiveReportSubmissionType.ByNonSubjectiveScouter,
       };
@@ -975,12 +976,12 @@ export namespace API {
 
       const matchIds = comp.matches.map((matchId) => new ObjectId(matchId));
       const matches = await db.findObjects<Match>(Collections.Matches, {
-        _id: { $in: matchIds },
+        _id: { $in: matchIds.map((id) => id.toString()) },
       });
 
       const reportIds = matches.flatMap((match) => match.subjectiveReports ?? []);
       const reports = await db.findObjects<SubjectiveReport>(Collections.SubjectiveReports, {
-        _id: { $in: reportIds.map((id) => new ObjectId(id)) },
+        _id: { $in: reportIds },
       });
 
       return res.status(200).send(reports);

lib/Auth.ts

@@ -3,11 +3,12 @@ import Google from "next-auth/providers/google";
 import GitHubProvider from "next-auth/providers/github";
 import SlackProvider from "next-auth/providers/slack";
 import { MongoDBAdapter } from "@next-auth/mongodb-adapter";
-import { Collections, getDatabase, clientPromise } from "./MongoDB";
+import { getDatabase, clientPromise } from "./MongoDB";
 import { Admin, ObjectId } from "mongodb";
 import { User } from "./Types";
 import { GenerateSlug } from "./Utils";
 import { Analytics } from '@/lib/client/Analytics';
+import Collections from "./client/Collections";
 
 var db = getDatabase();
 

lib/CompetitionHandeling.ts

@@ -1,4 +1,4 @@
-import { getDatabase, Collections } from "@/lib/MongoDB";
+import { getDatabase } from "@/lib/MongoDB";
 import {
   Competition,
   Match,
@@ -11,6 +11,7 @@ import { ObjectId } from "mongodb";
 import { rotateArray, shuffleArray } from "./client/ClientUtils";
 import { games } from "./games";
 import { GameId } from "./client/GameId";
+import Collections from "./client/Collections";
 
 export async function AssignScoutersToCompetitionMatches(
   teamId: string,
@@ -28,8 +29,8 @@ export async function AssignScoutersToCompetitionMatches(
     new ObjectId(teamId),
   );
   const matchIds = comp.matches;
-  let scouters = team.scouters;
-  let subjectiveScouters = team.subjectiveScouters;
+  let scouters = team?.scouters ?? [];
+  let subjectiveScouters = team?.subjectiveScouters ?? [];
 
   scouters = shuffle ? shuffleArray(scouters) : scouters;
   subjectiveScouters = shuffle ? shuffleArray(subjectiveScouters) : subjectiveScouters;

lib/MongoDB.ts

@@ -1,9 +1,12 @@
+import Collections from './client/Collections';
+import DbInterface from './client/DbInterface';
 import {
   Db,
+  Filter,
   MongoClient,
   MongoClientOptions,
   ObjectId,
-  UpdateResult,
+  Document,
 } from "mongodb";
 
 if (!process.env.MONGODB_URI) {
@@ -28,22 +31,6 @@ clientPromise = global.clientPromise;
 
 export { clientPromise };
 
-export enum Collections {
-  Seasons = "Seasons",
-  Competitions = "Competitions",
-  Matches = "Matches",
-  Reports = "Reports",
-  Teams = "Teams",
-  Users = "users",
-  Accounts = "accounts",
-  Sessions = "sessions",
-  Forms = "Forms",
-  Pitreports = "Pitreports",
-  Picklists = "Picklists",
-  SubjectiveReports = "SubjectiveReports",
-  SlackInstallations = "SlackInstallations",
-}
-
 export async function getDatabase(): Promise<MongoDBInterface> {
   if (!global.interface) {
     await clientPromise;
@@ -57,7 +44,7 @@ export async function getDatabase(): Promise<MongoDBInterface> {
   return global.interface;
 }
 
-export class MongoDBInterface {
+export class MongoDBInterface implements DbInterface {
   promise: Promise<MongoClient> | undefined;
   client: MongoClient | undefined;
   db: Db | undefined;
@@ -99,10 +86,10 @@ export class MongoDBInterface {
     collection: Collections,
     id: ObjectId,
     newValues: Partial<Type> | { [key: string]: any }
-  ): Promise<UpdateResult<Document> | undefined> {
+  ): Promise<void> {
     var query = { _id: id };
     var updated = { $set: newValues };
-    return this?.db
+    this?.db
       ?.collection(collection)
       .updateOne(query, updated);
   }
@@ -115,27 +102,27 @@ export class MongoDBInterface {
     return (await this?.db?.collection(collection).findOne(query)) as Type;
   }
 
-  async findObject<Type>(
+  async findObject<Type extends Document>(
     collection: Collections,
-    query: object
-  ): Promise<Type> {
-    return (await this?.db?.collection(collection).findOne(query)) as Type;
+    query: Filter<Type>
+  ): Promise<Type | undefined | null> {
+    return (await this?.db?.collection(collection).findOne(query as Document)) as Type | undefined | null;
   }
 
-  async findObjects<Type>(
+  async findObjects<Type extends Document>(
     collection: Collections,
-    query: object
+    query: Filter<Type>
   ): Promise<Type[]> {
     return (await this?.db
       ?.collection(collection)
-      .find(query)
-      .toArray()) as Type[];
+      .find(query as Document)
+      .toArray()) as unknown as Type[];
   }
 
-  async countObjects(
+  async countObjects<Type>(
     collection: Collections,
-    query: object
+    query: Filter<Type> | Type
   ): Promise<number | undefined> {
-    return await this?.db?.collection(collection).countDocuments(query);
+    return await this?.db?.collection(collection).countDocuments(query as Document);
   }
 }

lib/Slack.ts

@@ -1,6 +1,6 @@
 import { SlashCommand, AckFn, RespondArguments, RespondFn, App, Installation } from "@slack/bolt";
 import SlackCommands from "./SlackCommands";
-import { Collections, getDatabase } from "./MongoDB";
+import { getDatabase } from "./MongoDB";
 
 const slackApp = new App({
   // token: process.env.SLACK_BOT_TOKEN,
@@ -35,7 +35,7 @@ const slackApp = new App({
         }
       });
 
-      console.log("Found installation", installation.team?.name);
+      console.log("Found installation", installation?.team?.name);
 
       if (!installation) {
         throw new Error("No installation found");

lib/client/Collections.ts

@@ -0,0 +1,18 @@
+enum Collections {
+  Seasons = "Seasons",
+  Competitions = "Competitions",
+  Matches = "Matches",
+  Reports = "Reports",
+  Teams = "Teams",
+  Users = "users",
+  Accounts = "accounts",
+  Sessions = "sessions",
+  Forms = "Forms",
+  Pitreports = "Pitreports",
+  Picklists = "Picklists",
+  SubjectiveReports = "SubjectiveReports",
+  SlackInstallations = "SlackInstallations",
+}
+
+// We can't do export default enum Collections
+export default Collections;

lib/client/DbInterface.ts

@@ -0,0 +1,13 @@
+import { ObjectId, Document } from "bson";
+import Collections from "./Collections";
+
+export default interface DbInterface {
+  init(): Promise<void>;
+  addObject<Type>(collection: Collections, object: any): Promise<Type>;
+  deleteObjectById(collection: Collections, id: ObjectId): Promise<void>;
+  updateObjectById<Type>(collection: Collections, id: ObjectId, newValues: Partial<Type>): Promise<void>;
+  findObjectById<Type>(collection: Collections, id: ObjectId): Promise<Type>;
+  findObject<Type extends Document>(collection: Collections, query: object): Promise<Type | undefined | null>;
+  findObjects<Type extends Document>(collection: Collections, query: object): Promise<Type[]>;
+  countObjects<Type extends Document>(collection: Collections, query: object): Promise<number | undefined>;
+}

lib/client/MiniMongoInterface.ts

@@ -0,0 +1,109 @@
+import { ObjectId, Document } from "bson";
+import { LocalStorageDb, MinimongoDb } from "minimongo";
+import DbInterface from "./DbInterface";
+import Collections from "./Collections";
+
+export default class MiniMongoInterface implements DbInterface {
+  db: MinimongoDb | undefined;
+
+  init(): Promise<void>
+  {
+    this.db = new LocalStorageDb({}, console.log, console.error);
+
+    for (const collectionName in Collections)
+    {
+      this.db.addCollection(collectionName);
+    }
+
+    return Promise.resolve();
+  }
+
+  addObject<Type>(collection: Collections, object: any): Promise<Type>
+  {
+    const foundCollection = this.db?.collections[collection];
+
+    if (foundCollection)
+    {
+      foundCollection.upsert(object);
+      return Promise.resolve(object as Type);
+    }
+
+    return Promise.reject("Collection not found: " + collection);
+  }
+
+  deleteObjectById(collection: Collections, id: ObjectId): Promise<void>
+  {
+    const foundCollection = this.db?.collections[collection];
+
+    if (foundCollection)
+    {
+      foundCollection.remove(id.toHexString());
+      return Promise.resolve();
+    }
+
+    return Promise.reject("Collection not found: " + collection);
+  }
+
+  updateObjectById<Type>(collection: Collections, id: ObjectId, newValues: Partial<Type>): Promise<void>
+  {
+    const foundCollection = this.db?.collections[collection];
+
+    if (foundCollection)
+    {
+      foundCollection.upsert({ _id: id.toHexString(), ...newValues });
+      return Promise.resolve();
+    }
+
+    return Promise.reject("Collection not found: " + collection);
+  }
+
+  findObjectById<Type>(collection: Collections, id: ObjectId): Promise<Type>
+  {
+    const foundCollection = this.db?.collections[collection];
+
+    if (foundCollection)
+    {
+      return Promise.resolve(foundCollection.findOne(id.toHexString()) as Type);
+    }
+
+    return Promise.reject("Collection not found: " + collection);
+  }
+
+  findObject<Type extends Document>(collection: Collections, query: object): Promise<Type | undefined | null>
+  {
+    const foundCollection = this.db?.collections[collection];
+
+    if (foundCollection)
+    {
+      const foundObj = foundCollection.findOne(query);
+      return Promise.resolve(foundObj);
+    }
+
+    return Promise.reject("Collection not found: " + collection);
+  }
+
+  findObjects<Type>(collection: Collections, query: object): Promise<Type[]>
+  {
+    const foundCollection = this.db?.collections[collection];
+
+    if (foundCollection)
+    {
+      return foundCollection.find(query).fetch();
+    }
+
+    return Promise.reject("Collection not found: " + collection);
+  }
+
+  countObjects<Type>(collection: Collections, query: object): Promise<number | undefined>
+  {
+    const foundCollection = this.db?.collections[collection];
+
+    if (foundCollection)
+    {
+      return Promise.resolve(foundCollection.find(query).fetch().then((objs) => objs.length));
+    }
+
+    return Promise.reject("Collection not found: " + collection);
+  }
+
+}

lib/dev/FakeData.ts

@@ -1,8 +1,9 @@
 import { Team, User } from "../Types";
-import { getDatabase, Collections } from "../MongoDB";
+import { getDatabase } from "../MongoDB";
 import { GenerateSlug } from "../Utils";
 import { randomArrayValue } from "../client/ClientUtils";
 import { ObjectId } from "mongodb";
+import Collections from "../client/Collections";
 
 const firstNameMaleURL = "https://www.randomlists.com/data/names-male.json";
 const firstNameFemaleURL = "https://www.randomlists.com/data/names-female.json";