adding in old api

packages/api/services/database.service.ts

@@ -0,0 +1,34 @@
+// External Dependencies
+import * as mongoDB from "mongodb";
+
+import { loadConfig } from "../config";
+
+// Global Variables
+export const collections: {
+  users?: mongoDB.Collection;
+  lines?: mongoDB.Collection;
+  lineMembers?: mongoDB.Collection;
+} = {};
+
+// Initialize Connection
+const config = loadConfig();
+
+export const client: mongoDB.MongoClient = new mongoDB.MongoClient(
+  config.MONGO_CONNECTION_STRING
+);
+
+client.connect();
+
+const db: mongoDB.Db = client.db(process.env.DB_NAME);
+
+const usersCollection: mongoDB.Collection = db.collection("users");
+const lineCollection: mongoDB.Collection = db.collection("lines");
+const lineMembersCollection: mongoDB.Collection = db.collection("lineMembers");
+
+collections.users = usersCollection;
+collections.lines = lineCollection;
+collections.lineMembers = lineMembersCollection;
+
+console.log(
+  `Successfully connected to database: ${db.databaseName} and collections`
+);

packages/api/services/line.service.ts

@@ -0,0 +1,148 @@
+import {
+  Line,
+  LineMember,
+  LineMemberState,
+} from "@nirvana/core/models/line.model";
+import { client, collections } from "./database.service";
+
+import NirvanaResponse from "@nirvana/core/responses/nirvanaResponse";
+import { ObjectId } from "mongodb";
+
+export class LineService {
+  static async getLineByOtherUserId(otherUserId: ObjectId) {
+    // get all of the conversations for this user that have exactly two conversation members
+    // get all of the conversationMembers for this user
+    // get all of the conversations for this user
+    // get all of the conversations
+    // const query = { googleId: userId };
+    // const res = await collections.users?.findOne(query);
+    // // exists
+    // if (res?._id) {
+    //   return res as User;
+    // }
+    // return null;
+  }
+
+  static async getLinesByIds(convoIds: ObjectId[]) {
+    const query = { _id: { $in: convoIds } };
+
+    const convosRes = await collections.lines?.find(query).toArray();
+
+    // exists
+    if (convosRes?.length) {
+      return convosRes as Line[];
+    }
+
+    return null;
+  }
+
+  static async getLineMembersByUserId(userId: string) {
+    const query = { userId: new ObjectId(userId) };
+
+    const convoMembersRes = await collections.lineMembers
+      ?.find(query)
+      .toArray();
+
+    // exists
+    if (convoMembersRes?.length) {
+      return convoMembersRes as LineMember[];
+    }
+
+    return null;
+  }
+
+  /** Get all of the members associated to the given list of lines */
+  static async getLineMembersInLines(lineIds: ObjectId[]) {
+    const query = { lineId: { $in: lineIds } };
+
+    const lineMembersRes = await collections.lineMembers?.find(query).toArray();
+
+    // exists
+    if (lineMembersRes?.length) {
+      return lineMembersRes as LineMember[];
+    }
+
+    return null;
+  }
+
+  static async createLine(line: Line, lineMembers: LineMember[]) {
+    const session = client.startSession();
+    try {
+      const transactionResults = await session.withTransaction(async () => {
+        // todo: check if convoMembers userId's actually exist
+
+        const insertLineRes = await collections.lines?.insertOne(line);
+        if (!insertLineRes?.insertedId) {
+          await session.abortTransaction();
+          console.error("failed to create line");
+
+          return;
+        }
+
+        const insertConvoMembersRes = await collections.lineMembers?.insertMany(
+          lineMembers
+        );
+        if (!insertConvoMembersRes?.insertedCount) {
+          await session.abortTransaction();
+          console.error("failed to create line members");
+
+          return;
+        }
+
+        console.log("success");
+        return insertConvoMembersRes;
+      });
+
+      console.log(transactionResults);
+
+      return "success";
+
+      // if (transactionResults) {
+      //   console.log("The convo was successfully created.");
+      //   return transactionResults;
+      // } else {
+      //   console.log("The convo was intentionally aborted.");
+      //   return null;
+      // }
+    } catch (e) {
+      console.log(
+        "The transaction was aborted due to an unexpected error: " + e
+      );
+    } finally {
+      await session.endSession();
+    }
+
+    return null;
+  }
+
+  static async updateLineMemberState(
+    lineId: string,
+    userId: string,
+    newState: LineMemberState
+  ) {
+    const query = {
+      lineId: new ObjectId(lineId),
+      userId: new ObjectId(userId),
+    };
+    const updateSet = { $set: { state: newState, lastVisitDate: new Date() } };
+
+    const updateRes = await collections.lineMembers?.findOneAndUpdate(
+      query,
+      updateSet
+    );
+
+    return updateRes;
+  }
+
+  static async updateLineMemberVisitDate(lineId: string, userId: string) {
+    const query = { lineId, userId: new ObjectId(userId) };
+    const updateSet = { $set: { lastVisitDate: new Date() } };
+
+    const updateRes = await collections.lineMembers?.findOneAndUpdate(
+      query,
+      updateSet
+    );
+
+    return updateRes;
+  }
+}

packages/api/services/user.service.ts

@@ -0,0 +1,118 @@
+import { GoogleUserInfo, User } from "@nirvana/core/models";
+
+import { ObjectId } from "mongodb";
+import { UserStatus } from "../../core/models/user.model";
+import axios from "axios";
+import { collections } from "./database.service";
+
+export class UserService {
+  static async getUserById(userId: string) {
+    const query = { _id: new ObjectId(userId) };
+
+    const res = await collections.users?.findOne(query);
+
+    // exists
+    if (res?._id) {
+      return res as User;
+    }
+
+    return null;
+  }
+
+  static async getUsersByIds(userIds: ObjectId[]) {
+    const query = { _id: { $in: userIds } };
+
+    const res = await collections.users?.find(query).toArray();
+
+    // exists
+    if (res?.length) {
+      return res as User[];
+    }
+
+    return undefined;
+  }
+
+  static async getUserByGoogleId(googleUserId: string) {
+    const query = { googleId: googleUserId };
+
+    const res = await collections.users?.findOne(query);
+
+    // exists
+    if (res?._id) {
+      return res as User;
+    }
+
+    return null;
+  }
+
+  static async getUserByEmail(email: string) {
+    const query = { email };
+
+    const res = await collections.users?.findOne(query);
+
+    // exists
+    if (res?._id) {
+      return res as User;
+    }
+
+    return null;
+  }
+
+  static async getUsersLikeEmailAndName(searchQuery: string) {
+    // based on index defined in Mongo atlas
+    const query = {
+      $search: {
+        index: "basic user search",
+        text: {
+          query: searchQuery,
+          path: {
+            wildcard: "*",
+          },
+        },
+      },
+    };
+
+    // const res = await collections.users?.find(query).toArray();
+
+    const res = await collections.users?.aggregate([query]).toArray();
+
+    // exists
+    if (res?.length) {
+      return res as User[];
+    }
+
+    return null;
+  }
+
+  static async createUserIfNotExists(newUser: User) {
+    const getUser = await this.getUserByEmail(newUser.email);
+
+    if (!getUser) {
+      return await collections.users?.insertOne(newUser);
+    }
+
+    // user with email exists already, don't create
+    return null;
+  }
+
+  static async getGoogleUserInfoWithAccessToken(
+    accessToken: string
+  ): Promise<GoogleUserInfo> {
+    return (
+      await axios.get(
+        `https://www.googleapis.com/oauth2/v1/userinfo?access_token=${accessToken}`
+      )
+    ).data;
+  }
+
+  static async updateUserStatus(userGoogleId: string, newStatus: UserStatus) {
+    const query = { googleId: userGoogleId };
+    const updateDoc = {
+      $set: { status: newStatus, lastUpdatedDate: new Date() },
+    };
+
+    const resultUpdate = await collections.users?.updateOne(query, updateDoc);
+
+    return resultUpdate;
+  }
+}