Fix env usage and mongoose model type issues

nahasonnyaga · nahasonnyaga · commit 6a672586409c · 2025-11-02T00:16:15.000+03:00
diff --git a/functions/src/api/notify-email.ts b/functions/src/api/notify-email.ts
@@ -0,0 +1,28 @@
+// functions/src/api/notify-email.ts
+import type { VercelRequest, VercelResponse } from '@vercel/node';
+import { notifyEmail, TweetData } from '../notify-email';
+
+/**
+ * Vercel serverless function to send email notifications
+ * Expects POST request with JSON body: { id, text, createdBy, username, images?, parent? }
+ */
+export default async function handler(req: VercelRequest, res: VercelResponse) {
+  try {
+    if (req.method !== 'POST') {
+      return res.status(405).json({ error: 'Method not allowed' });
+    }
+
+    const tweetData: TweetData = req.body;
+
+    if (!tweetData || !tweetData.id || !tweetData.text || !tweetData.createdBy || !tweetData.username) {
+      return res.status(400).json({ error: 'Invalid tweet data' });
+    }
+
+    await notifyEmail(tweetData);
+
+    res.status(200).json({ message: 'Notification email sent' });
+  } catch (error) {
+    console.error('Error sending notification email:', error);
+    res.status(500).json({ error: 'Internal Server Error' });
+  }
+}
diff --git a/functions/src/lib/utils.ts b/functions/src/lib/utils.ts
@@ -1,6 +1,23 @@
-import * as functions from 'firebase-functions';
+// functions/src/lib/utils.ts
+import mongoose from 'mongoose';
+import { MONGO_URI } from './env';
 
-const regionalFunctions = functions.region('asia-southeast2');
+/**
+ * Connect to MongoDB
+ */
+export async function connectMongo() {
+  if (!mongoose.connection.readyState) {
+    await mongoose.connect(MONGO_URI, {
+      autoIndex: true,
+      dbName: 'twitter_clone',
+    });
+    console.log('✅ Connected to MongoDB');
+  }
+}
 
-export { firestore } from 'firebase-admin';
-export { functions, regionalFunctions };
+/**
+ * Optional helper: delay (can replace Firebase async helpers)
+ */
+export function delay(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
diff --git a/functions/src/mongo/models/Hashtag.ts b/functions/src/mongo/models/Hashtag.ts
@@ -1,10 +1,20 @@
 // functions/src/mongo/models/Hashtag.ts
-import { Schema, model, models } from 'mongoose';
+import { Schema, model, models, Types, Model, Document } from 'mongoose';
 
-const HashtagSchema = new Schema({
-  tag: { type: String, required: true, unique: true },
-  tweetIds: { type: [String], default: [] },
-  count: { type: Number, default: 1 },
+// Define interface for a Hashtag document
+interface HashtagDocument extends Document {
+  tag: string;
+  count: number;
+  tweets: Types.ObjectId[];
+  createdAt: Date;
+}
+
+const HashtagSchema = new Schema<HashtagDocument>({
+  tag: { type: String, required: true, unique: true },       // the hashtag text
+  count: { type: Number, default: 1 },                        // number of times used
+  tweets: [{ type: Types.ObjectId, ref: 'Tweet' }],          // references to Tweet documents
+  createdAt: { type: Date, default: Date.now },
 });
 
-export const Hashtag = models.Hashtag || model('Hashtag', HashtagSchema);
+// Fix TS union type issue while keeping logic original
+export const Hashtag: Model<HashtagDocument> = models.Hashtag || model<HashtagDocument>('Hashtag', HashtagSchema);
diff --git a/functions/src/mongo/models/Tweet.ts b/functions/src/mongo/models/Tweet.ts
@@ -1,13 +1,14 @@
-import { Schema, model, models } from 'mongoose';
+import { Schema, model, models, Types } from 'mongoose';
 
 const TweetSchema = new Schema({
+  firebaseId: { type: String, required: true, unique: true }, // link to Firestore
   text: { type: String, required: true },
   createdBy: { type: String, required: true },
   username: { type: String, required: true },
   userAvatar: { type: String, default: "" },
   images: { type: [String], default: [] },
   videos: { type: [String], default: [] },
-  tags: { type: [String], default: [] },
+  hashtags: { type: [String], default: [] }, // renamed from tags
   likes: { type: Number, default: 0 },
   comments: { type: Number, default: 0 },
   retweets: { type: Number, default: 0 },
diff --git a/functions/src/mongo/updateTags.ts b/functions/src/mongo/updateTags.ts
@@ -2,36 +2,76 @@
 import { Hashtag } from './models/Hashtag';
 import { Mention } from './models/Mention';
 import { Trending } from './models/Trending';
+import { Tweet } from './models/Tweet';
+import { Types } from 'mongoose';
 
-export async function processTags(tweetId: string, text: string) {
+interface TweetData {
+  firebaseId: string;
+  text: string;
+  createdBy: string;
+  username: string;
+  userAvatar?: string;
+  images?: string[];
+  videos?: string[];
+}
+
+export async function processTags(tweetData: TweetData) {
+  const { firebaseId, text, createdBy, username, userAvatar, images = [], videos = [] } = tweetData;
+
+  // 1️⃣ Insert tweet into Mongo (or skip if already exists)
+  let mongoTweet = await Tweet.findOne({ firebaseId });
+  if (!mongoTweet) {
+    mongoTweet = await Tweet.create({
+      firebaseId,
+      text,
+      createdBy,
+      username,
+      userAvatar: userAvatar || "",
+      images,
+      videos,
+      hashtags: [],
+    });
+  }
+
+  // 2️⃣ Extract hashtags and mentions
   const hashtags = Array.from(text.matchAll(/#(\w+)/g)).map(m => m[1].toLowerCase());
   const mentions = Array.from(text.matchAll(/@(\w+)/g)).map(m => m[1].toLowerCase());
 
-  // Hashtags
+  // 3️⃣ Update hashtags in Mongo
   for (const tag of hashtags) {
-    await Hashtag.findOneAndUpdate(
+    const hashtag = await Hashtag.findOneAndUpdate(
       { tag },
-      { $addToSet: { tweetIds: tweetId }, $inc: { count: 1 } },
-      { upsert: true }
+      { $addToSet: { tweets: mongoTweet._id }, $inc: { count: 1 } },
+      { upsert: true, new: true }
     );
+    mongoTweet.hashtags.push(tag);
+
+    // Update Trending collection
     await Trending.findOneAndUpdate(
       { type: 'hashtag', value: tag },
       { $inc: { score: 1 } },
       { upsert: true }
     );
   }
 
-  // Mentions
+  // 4️⃣ Update mentions in Mongo
   for (const username of mentions) {
     await Mention.findOneAndUpdate(
       { username },
-      { $addToSet: { tweetIds: tweetId }, $inc: { count: 1 } },
+      { $addToSet: { tweetIds: mongoTweet._id }, $inc: { count: 1 } },
       { upsert: true }
     );
+
+    // Update Trending collection
     await Trending.findOneAndUpdate(
       { type: 'mention', value: username },
       { $inc: { score: 1 } },
       { upsert: true }
     );
   }
+
+  // 5️⃣ Save updated tweet hashtags array
+  await mongoTweet.save();
+
+  return mongoTweet;
 }
diff --git a/functions/src/notify-email.ts b/functions/src/notify-email.ts
@@ -1,45 +1,53 @@
+// functions/src/notify-email.ts
 import { createTransport } from 'nodemailer';
-import { firestore, functions, regionalFunctions } from './lib/utils';
+import { connectMongo } from './lib/utils';
 import { EMAIL_API, EMAIL_API_PASSWORD, TARGET_EMAIL } from './lib/env';
-import type { Tweet, User } from './types';
-
-export const notifyEmail = regionalFunctions.firestore
-  .document('tweets/{tweetId}')
-  .onCreate(async (snapshot): Promise<void> => {
-    functions.logger.info('Sending notification email.');
-
-    const { text, createdBy, images, parent } = snapshot.data() as Tweet;
-
-    const imagesLength = images?.length ?? 0;
-
-    const { name, username } = (
-      await firestore().doc(`users/${createdBy}`).get()
-    ).data() as User;
-
-    const client = createTransport({
-      service: 'Gmail',
-      auth: {
-        user: EMAIL_API.value(),
-        pass: EMAIL_API_PASSWORD.value()
-      }
-    });
-
-    const tweetLink = `https://twitter-clone-ccrsxx.vercel.app/tweet/${snapshot.id}`;
-
-    const emailHeader = `New Tweet${
-      parent ? ' reply' : ''
-    } from ${name} (@${username})`;
+import { Tweet } from './mongo/models/Tweet';
+
+export interface TweetData {
+  id: string;
+  text: string;
+  createdBy: string;
+  username: string;
+  images?: string[];
+  parent?: string;
+}
+
+/**
+ * Send notification email when a new tweet is created
+ */
+export async function notifyEmail(tweetData: TweetData) {
+  const { id, text, createdBy, username, images = [], parent } = tweetData;
+
+  // Connect to MongoDB
+  await connectMongo();
+
+  // Fetch user from MongoDB (fallback to payload if not found)
+  const user = await Tweet.findOne({ _id: createdBy });
+  const name = user?.username || username;
+
+  const client = createTransport({
+    service: 'Gmail',
+    auth: {
+      user: EMAIL_API.value(),
+      pass: EMAIL_API_PASSWORD.value(),
+    },
+  });
 
-    const emailText = `${text ?? 'No text provided'}${
-      images ? ` (${imagesLength} image${imagesLength > 1 ? 's' : ''})` : ''
-    }\n\nLink to Tweet: ${tweetLink}\n\n- Firebase Function.`;
+  const imagesLength = images.length;
+  const tweetLink = `https://twitter-clone-ccrsxx.vercel.app/tweet/${id}`;
 
-    await client.sendMail({
-      from: EMAIL_API.value(),
-      to: TARGET_EMAIL.value(),
-      subject: emailHeader,
-      text: emailText
-    });
+  const emailHeader = `New Tweet${parent ? ' reply' : ''} from ${name} (@${username})`;
+  const emailText = `${text ?? 'No text provided'}${
+    imagesLength ? ` (${imagesLength} image${imagesLength > 1 ? 's' : ''})` : ''
+  }\n\nLink to Tweet: ${tweetLink}\n\n- Vercel Serverless Function`;
 
-    functions.logger.info('Notification email sent.');
+  await client.sendMail({
+    from: EMAIL_API.value(),
+    to: TARGET_EMAIL.value(),
+    subject: emailHeader,
+    text: emailText,
   });
+
+  console.log(`📧 Notification email sent for tweet ${id}`);
+}
diff --git a/src/lib/api/tweets.ts b/src/lib/api/tweets.ts
@@ -1,20 +1,52 @@
 // src/lib/api/tweets.ts
-import { getFunctions, httpsCallable } from "firebase/functions";
 
-// Example createTweet function placeholder — replace with your actual implementation
-async function createTweet({ text, file, userId }: any) {
-  // Save tweet in Firestore or wherever you store it
-  return { id: "some-tweet-id", text };
+export interface CreateTweetParams {
+  text: string;
+  file?: string[];          // Array of uploaded image URLs
+  userId: string;           // ID of the user creating the tweet
+  username: string;         // Username of the creator
+  parent?: string;          // Optional parent tweet ID (if this is a reply)
 }
 
-export async function createTweetWithTags({ text, file, userId }: any) {
+export async function createTweetWithTags({
+  text,
+  file,
+  userId,
+  username,
+  parent
+}: CreateTweetParams) {
   // 1️⃣ Create the tweet locally
-  const tweet = await createTweet({ text, file, userId });
+  const tweet = {
+    id: crypto.randomUUID(),     // Unique local ID
+    text,
+    createdBy: userId,
+    username,
+    images: file ?? [],
+    parent
+  };
 
-  // 2️⃣ Call Firebase Function to handle hashtags & mentions in Mongo
-  const functions = getFunctions();
-  const createTweetMongo = httpsCallable(functions, "createTweetMongo");
-  await createTweetMongo({ tweetId: tweet.id, text: tweet.text });
+  // 2️⃣ Call both Vercel APIs in parallel
+  try {
+    await Promise.all([
+      // Mirror tweet in Mongo & process hashtags/mentions
+      fetch('/api/createTweetMongo', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(tweet),
+      }),
+      
+      // Send notification email
+      fetch('/api/notify-email', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(tweet),
+      })
+    ]);
+  } catch (error) {
+    console.error('Error processing tweet on server:', error);
+    // Optionally handle failure: retry, queue, or notify admin
+  }
 
+  // 3️⃣ Return local tweet immediately
   return tweet;
 }
diff --git a/src/pages/api/createTweetMongo.ts b/src/pages/api/createTweetMongo.ts
@@ -0,0 +1,45 @@
+// src/pages/api/createTweetMongo.ts
+import type { NextApiRequest, NextApiResponse } from 'next';
+import mongoose from 'mongoose';
+import { processTags } from '../../../functions/src/mongo/updateTags';
+
+// Use process.env for server-side env variables
+const MONGO_URI = process.env.MONGO_URI!;
+
+// Ensure Mongo is connected
+async function connectMongo() {
+  if (mongoose.connection.readyState === 0) {
+    await mongoose.connect(MONGO_URI);
+  }
+}
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  try {
+    const { tweetId, text, createdBy, username, userAvatar, images, videos } = req.body;
+
+    if (!tweetId || !text || !createdBy || !username) {
+      return res.status(400).json({ error: 'Missing required fields' });
+    }
+
+    await connectMongo();
+
+    const mongoTweet = await processTags({
+      firebaseId: tweetId,
+      text,
+      createdBy,
+      username,
+      userAvatar,
+      images,
+      videos
+    });
+
+    return res.status(200).json({ success: true, mongoTweet });
+  } catch (err) {
+    console.error('Error in createTweetMongo:', err);
+    return res.status(500).json({ error: 'Internal server error' });
+  }
+}
diff --git a/src/pages/api/handle-new-tweet.ts b/src/pages/api/handle-new-tweet.ts
diff --git a/src/pages/api/notify-email.ts b/src/pages/api/notify-email.ts
