Introduction to NoSQL

-- Our SQL schema attempt
CREATE TABLE posts (
    id INT PRIMARY KEY,
    user_id INT,
    content TEXT,
    created_at TIMESTAMP
);

CREATE TABLE comments (
    id INT PRIMARY KEY,
    post_id INT,
    user_id INT,
    content TEXT,
    parent_comment_id INT  -- For nested replies
);

CREATE TABLE likes (
    user_id INT,
    post_id INT,
    PRIMARY KEY (user_id, post_id)
);

CREATE TABLE media (
    id INT PRIMARY KEY,
    post_id INT,
    media_type VARCHAR(10),
    url VARCHAR(255)
);

-- Getting a single post with all its data requires...
SELECT p.*, u.username, u.avatar,
       COUNT(DISTINCT l.user_id) as like_count,
       COUNT(DISTINCT c.id) as comment_count
FROM posts p
JOIN users u ON p.user_id = u.id
LEFT JOIN likes l ON p.id = l.post_id
LEFT JOIN comments c ON p.id = c.post_id
LEFT JOIN media m ON p.id = m.post_id
WHERE p.id = 123
GROUP BY p.id, u.username, u.avatar;

-- And we haven't even loaded the actual comments yet!

-- Loading a feed of 20 posts with all their data
-- This query would need to join across 6+ tables
-- For each post, potentially hundreds of rows
-- Result: Slow loading feeds that users hate!

// A single post in MongoDB (a document database)
{
  "_id": "507f1f77bcf86cd799439011",
  "user": {
    "id": "user123",
    "username": "coolcoder",
    "avatar": "https://..."
  },
  "content": "Just built my first app! 🚀",
  "media": [
    {
      "type": "image",
      "url": "https://...",
      "thumbnail": "https://..."
    }
  ],
  "likes": ["user456", "user789", "user321"],
  "likeCount": 3,
  "comments": [
    {
      "id": "comment1",
      "user": {
        "id": "user456",
        "username": "bestfriend"
      },
      "content": "Amazing work!",
      "timestamp": "2024-01-15T10:30:00Z",
      "replies": [
        {
          "user": {"id": "user123", "username": "coolcoder"},
          "content": "Thanks! 😊",
          "timestamp": "2024-01-15T10:35:00Z"
        }
      ]
    }
  ],
  "hashtags": ["coding", "firstapp", "mongodb"],
  "timestamp": "2024-01-15T10:00:00Z"
}

// Real-world example: Instagram likes
// They chose AP (Availability + Partition Tolerance)
// Result: Like counts might be slightly different 
// for different users momentarily, but the app never goes down

// MongoDB in action
const { MongoClient } = require('mongodb');

// Connect to MongoDB
const client = new MongoClient('mongodb://localhost:27017');
const db = client.db('telebortgram');
const posts = db.collection('posts');

// Creating a post - so much simpler!
async function createPost(userId, content, media) {
  const post = {
    user: await getUserInfo(userId),
    content: content,
    media: media || [],
    likes: [],
    likeCount: 0,
    comments: [],
    hashtags: extractHashtags(content),
    timestamp: new Date()
  };
  
  return await posts.insertOne(post);
}

// Getting the feed - one query!
async function getFeed(userId, limit = 20) {
  return await posts
    .find({ "user.followers": userId })
    .sort({ timestamp: -1 })
    .limit(limit)
    .toArray();
}

// Real-time like updates
async function likePost(postId, userId) {
  return await posts.updateOne(
    { _id: postId },
    { 
      $addToSet: { likes: userId },
      $inc: { likeCount: 1 }
    }
  );
}

// Nested comments with replies
async function addComment(postId, userId, content, parentCommentId = null) {
  const comment = {
    id: generateId(),
    user: await getUserInfo(userId),
    content: content,
    timestamp: new Date(),
    replies: []
  };
  
  if (parentCommentId) {
    // Add as a reply
    return await posts.updateOne(
      { _id: postId, "comments.id": parentCommentId },
      { $push: { "comments.$.replies": comment } }
    );
  } else {
    // Add as top-level comment
    return await posts.updateOne(
      { _id: postId },
      { $push: { comments: comment } }
    );
  }
}

// Start your design here:
const storyDocument = {
  // Your structure...
};