mongo implementation 🐺

Author: 0xheartcode

.env.local

@@ -1,2 +1,3 @@
 MAKEFILE_OVERWRITE_DOCKERNAME=
 INITIAL_BEARER_TOKEN=
+MONGO_URI=

package.json

@@ -17,6 +17,7 @@
     "form-data": "^4.0.0",
     "google-auth-library": "^9.14.0",
     "googleapis": "^140.0.1",
+    "mongodb": "^6.9.0",
     "open": "^10.1.0",
     "whatwg-url": "^14.0.0"
   },

src/app.ts

@@ -1,10 +1,13 @@
 import express from 'express';
 import routes from './routes';
-import { checkRequiredEnvVariables } from './dbcode/dbSetup';
+import { checkRequiredEnvVariables, initializeDatabase } from './dbcode/dbSetup';
 
 // Check required environment variables
 checkRequiredEnvVariables();
 
+// Initialize database connection
+await initializeDatabase();
+
 const app = express();
 const PORT = 8080;
 

src/dbcode/dbSetup.ts

@@ -1,27 +1,23 @@
-// src/dbCode/dbSetup.ts
+// src/dbcode/dbSetup.ts
+
 import fs from 'fs';
 import path from 'path';
 import dotenv from 'dotenv';
-import dbClient from '../dbcode/dbClient';
+import MongoDbClient from './mongoDbClient';
 
 const envPath = path.resolve(process.cwd(), '.env');
 const envLocalPath = path.resolve(process.cwd(), '.env.local');
 
 if (fs.existsSync(envPath)) {
   dotenv.config({ path: envPath });
-  //console.log('.env file found and loaded');
 } else if (fs.existsSync(envLocalPath)) {
   dotenv.config({ path: envLocalPath });
-  //console.log('.env.local file found and loaded');
 } else {
   console.log('Neither .env nor .env.local file found.');
 }
 
 export function checkRequiredEnvVariables() {
-  const requiredVariables: string[] = [
-    // Add your required variables here
-    // For example: 'DATABASE_URL', 'API_KEY', etc.
-  ];
+  const requiredVariables = ['MONGO_URI' ];
 
   for (const variable of requiredVariables) {
     if (!process.env[variable]) {
@@ -33,17 +29,26 @@ export function checkRequiredEnvVariables() {
   console.log('All required environment variables are set.');
 }
 
-export function initializeTokens() {
-  const bearerToken = process.env.INITIAL_BEARER_TOKEN;
+let dbClient: MongoDbClient;
+
+export async function initializeDatabase() {
+  const mongoUri = process.env.MONGO_URI as string;
 
+  dbClient = new MongoDbClient(mongoUri);
+  await dbClient.connect();
+
+  const bearerToken = process.env.INITIAL_BEARER_TOKEN;
   if (bearerToken) {
-    if (dbClient.getCurrentBearerTokenDB() === null) {
-      dbClient.setBearerTokenDB(bearerToken);
+    const currentToken = await dbClient.getCurrentBearerTokenDB();
+    if (currentToken === null) {
+      await dbClient.setBearerTokenDB(bearerToken);
       console.log('Initial bearer token set from environment variable');
     }
   } else {
     console.log('No initial bearer token provided in environment variables');
   }
 }
 
+export { dbClient };
+
 console.log('Database setup module loaded');

src/dbcode/mongoDbClient.ts

@@ -0,0 +1,51 @@
+// src/dbcode/mongoDbClient.ts
+
+import { MongoClient, Db } from 'mongodb';
+import { IDbClient } from '../types/dbInterfaces';
+
+class MongoDbClient implements IDbClient {
+  private client: MongoClient;
+  private db: Db | null = null;
+
+  constructor(uri: string) {
+    this.client = new MongoClient(uri);
+  }
+
+  async connect() {
+    await this.client.connect();
+    this.db = this.client.db('yourDatabaseName');
+    console.log('Connected to MongoDB');
+  }
+
+  async setBearerTokenDB(token: string): Promise<boolean> {
+    if (!this.db) throw new Error('Database not connected');
+    const collection = this.db.collection('bearer_tokens');
+    const existingToken = await collection.findOne({});
+    if (existingToken) return false;
+    await collection.insertOne({ token });
+    return true;
+  }
+
+  async isValidBearerTokenDB(token: string): Promise<boolean> {
+    if (!this.db) throw new Error('Database not connected');
+    const collection = this.db.collection('bearer_tokens');
+    const result = await collection.findOne({ token });
+    return !!result;
+  }
+
+  async getCurrentBearerTokenDB(): Promise<string | null> {
+    if (!this.db) throw new Error('Database not connected');
+    const collection = this.db.collection('bearer_tokens');
+    const result = await collection.findOne({});
+    return result ? result.token : null;
+  }
+
+  async changeBearerTokenDB(currentToken: string, newToken: string): Promise<boolean> {
+    if (!this.db) throw new Error('Database not connected');
+    const collection = this.db.collection('bearer_tokens');
+    const result = await collection.updateOne({ token: currentToken }, { $set: { token: newToken } });
+    return result.modifiedCount > 0;
+  }
+}
+
+export default MongoDbClient;

src/handlers/basicHandler.ts

@@ -1,40 +1,47 @@
 import { Request, Response } from 'express';
-import dbClient from '../dbcode/dbClient';
+import { dbClient } from '../dbcode/dbSetup';
 
-export function ping(req: Request, res: Response) {
+export async function ping(req: Request, res: Response) {
   res.send('Pong!');
 }
 
-export function safePing(req: Request, res: Response) {
+export async function safePing(req: Request, res: Response) {
   res.send('Safe Pong!');
 }
 
-export function getCurrentToken(req: Request, res: Response) {
-  const token = dbClient.getCurrentBearerTokenDB();
-  if (token) {
-    res.json({ token });
-  } else {
-    res.status(404).json({ error: 'No Bearer Token set' });
+export async function getCurrentToken(req: Request, res: Response) {
+  try {
+    const token = await dbClient.getCurrentBearerTokenDB();
+    if (token) {
+      res.json({ token });
+    } else {
+      res.status(404).json({ error: 'No Bearer Token set' });
+    }
+  } catch (error) {
+    res.status(500).json({ error: 'Internal Server Error' });
   }
 }
 
-export function setNewBearerToken(req: Request, res: Response) {
+export async function setNewBearerToken(req: Request, res: Response) {
   const { token } = req.body;
 
   if (!token) {
     return res.status(400).json({ error: 'Token is required' });
   }
 
-  const result = dbClient.setBearerTokenDB(token);
-
-  if (result) {
-    res.status(201).json({ message: 'Bearer Token set successfully' });
-  } else {
-    res.status(409).json({ error: 'Bearer Token has already been set' });
+  try {
+    const result = await dbClient.setBearerTokenDB(token);
+    if (result) {
+      res.status(201).json({ message: 'Bearer Token set successfully' });
+    } else {
+      res.status(409).json({ error: 'Bearer Token has already been set' });
+    }
+  } catch (error) {
+    res.status(500).json({ error: 'Internal Server Error' });
   }
 }
 
-export function changeBearerToken(req: Request, res: Response) {
+export async function changeBearerToken(req: Request, res: Response) {
   const authHeader = req.headers.authorization;
   const { newToken } = req.body;
 
@@ -48,15 +55,19 @@ export function changeBearerToken(req: Request, res: Response) {
 
   const currentToken = authHeader.split(' ')[1];
 
-  if (!dbClient.isValidBearerTokenDB(currentToken)) {
-    return res.status(401).json({ error: 'Invalid Bearer Token' });
-  }
-
-  const result = dbClient.changeBearerTokenDB(currentToken, newToken);
+  try {
+    const isValid = await dbClient.isValidBearerTokenDB(currentToken);
+    if (!isValid) {
+      return res.status(401).json({ error: 'Invalid Bearer Token' });
+    }
 
-  if (result) {
-    res.json({ message: 'Bearer Token changed successfully' });
-  } else {
-    res.status(500).json({ error: 'Failed to change Bearer Token' });
+    const result = await dbClient.changeBearerTokenDB(currentToken, newToken);
+    if (result) {
+      res.json({ message: 'Bearer Token changed successfully' });
+    } else {
+      res.status(500).json({ error: 'Failed to change Bearer Token' });
+    }
+  } catch (error) {
+    res.status(500).json({ error: 'Internal Server Error' });
   }
 }

src/middleware/auth.ts

@@ -1,16 +1,20 @@
 import { Request, Response, NextFunction } from 'express';
-import dbClient from '../dbcode/dbClient';
+import { dbClient } from '../dbcode/dbSetup';
 
-export function authenticateToken(req: Request, res: Response, next: NextFunction) {
+export async function authenticateToken(req: Request, res: Response, next: NextFunction) {
   const authHeader = req.headers.authorization;
   if (!authHeader || !authHeader.startsWith('Bearer ')) {
     return res.status(401).json({ error: 'Unauthorized: No bearer token provided' });
   }
 
   const bearerToken = authHeader.split(' ')[1];
-  if (!dbClient.isValidBearerTokenDB(bearerToken)) {
-    return res.status(401).json({ error: 'Unauthorized: Invalid bearer token' });
+  try {
+    const isValid = await dbClient.isValidBearerTokenDB(bearerToken);
+    if (!isValid) {
+      return res.status(401).json({ error: 'Unauthorized: Invalid bearer token' });
+    }
+    next();
+  } catch (error) {
+    return res.status(500).json({ error: 'Internal Server Error' });
   }
-
-  next();
 }

src/types/dbInterfaces.ts

@@ -5,8 +5,8 @@ export interface ITokenResult {
 }
 
 export interface IDbClient {
-  setBearerTokenDB(token: string): boolean;
-  isValidBearerTokenDB(token: string): boolean;
-  getCurrentBearerTokenDB(): string | null;
-  changeBearerTokenDB(currentToken: string, newToken: string): boolean;
+  setBearerTokenDB(token: string): Promise<boolean>;
+  isValidBearerTokenDB(token: string): Promise<boolean>;
+  getCurrentBearerTokenDB(): Promise<string | null>;
+  changeBearerTokenDB(currentToken: string, newToken: string): Promise<boolean>;
 }