Sprint dec2025

remote-ide/app/Api/User/route.ts

@@ -1,71 +1,40 @@
-import mongoose from "mongoose";
-import UserModel from "./modals/User";
-import { NextRequest, NextResponse } from "next/server";
-
-// Connect to MongoDB
-async function connectDB() {
-  try {
-    await mongoose.connect(process.env.MONGODB_URI as string);
-    console.log("Connected to MongoDB");
-  } catch (error) {
-    console.error("MongoDB connection error:", error);
-    throw error;
-  }
-}
-await connectDB();
+import { NextRequest, NextResponse } from "next/server"
+import { auth } from "@clerk/nextjs/server"
+import { connectToDB } from "@/server/db/mongoose"
+import { User } from "@/server/models/models"
 
 export async function POST(req: NextRequest) {
-  const body = await req.json();
-  const { userId, name } = body;
+  const { userId } = await auth()
 
-  try {
-
-    // Check if user exists
-    const existingUser = await UserModel.findOne({ id: userId });
-    if (existingUser) {
-      return NextResponse.json(existingUser, { status: 200 });
-    }
-
-    // Create new user if not exists
-    const newUser = {
-      id: userId,
-      name: name,
-      projects: [],
-    };
-
-    const createdUser = await UserModel.create(newUser);
-
-    return NextResponse.json(createdUser, { status: 200 });
-  } catch (error) {
-    console.error("Error creating user:", error);
-    return NextResponse.json({ error: "Server error" }, { status: 500 });
+  if (!userId) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 })
   }
-}
 
+  const body = await req.json().catch(() => ({}))
+  const name = body?.name ?? "User"
 
-// end-point for updating projects in the userd database
-export async function PUT(req: NextRequest) {
   try {
-    const body = await req.json();
-    const { userId, updatedprojects } = body;
-
-    if (!userId || !Array.isArray(updatedprojects)) {
-      return NextResponse.json({ error: "Invalid data" }, { status: 400 });
-    }
+    await connectToDB();
 
-    const updatedUser = await UserModel.findOneAndUpdate(
-      { id: userId },
-      { $set: { projects: updatedprojects } },
-      { new: true }
-    );
+    let user = await User.findOne({ authId: userId })
 
-    if (!updatedUser) {
-      return NextResponse.json({ error: "User not found" }, { status: 404 });
+    if (!user) {
+      user = await User.create({
+        authId: userId,
+        name,
+      })
     }
 
-    return NextResponse.json({ message: "User updated", user: updatedUser }, { status: 200 });
+    return NextResponse.json(
+      {
+        id: user._id.toString(),
+        name: user.name,
+        createdAt: user.createdAt,
+      },
+      { status: 201 }
+    )
   } catch (err) {
-    console.error("Error updating user:", err);
-    return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    console.error("User init error:", err)
+    return NextResponse.json({ error: "Server error" }, { status: 500 })
   }
 }

remote-ide/app/Api/projects/[projectId]/route.ts

@@ -0,0 +1,74 @@
+import { NextRequest, NextResponse } from "next/server"
+import { auth } from "@clerk/nextjs/server"
+import { connectToDB } from "@/server/db/mongoose"
+import { Project, Document } from "@/server/models/models"
+import mongoose from "mongoose"
+
+// builds nested list 
+function buildTree(nodes: any[]) {
+    const map = new Map()
+    let root = null
+
+    for (const node of nodes) {
+        map.set(node._id.toString(), {
+            id: node._id.toString(),
+            name: node.name,
+            type: node.type,
+            extension: node.extension,
+            children: [],
+        })
+    }
+
+    for (const node of nodes) {
+        const id = node._id.toString()
+        if (node.parent) {
+            const parent = map.get(node.parent.toString())
+            parent.children.push(map.get(id))
+        } else {
+            root = map.get(id)
+        }
+    }
+    return root;
+}
+
+export async function GET(
+    req: NextRequest,
+    ctx: { params: Promise<{ projectId: string }> }
+) {
+    const { userId } = await auth()
+    if (!userId) {
+        return NextResponse.json({ error: "Unauthorized" }, { status: 401 })
+    }
+
+    const { projectId } = await ctx.params
+
+    if (!mongoose.Types.ObjectId.isValid(projectId)) {
+        return NextResponse.json({ error: "Invalid project id" }, { status: 400 })
+    }
+
+    await connectToDB()
+
+    const project = await Project.findById(projectId).populate("owner")
+
+    if (!project || project.owner.authId !== userId) {
+        return NextResponse.json({ error: "Not found" }, { status: 404 })
+    }
+
+    const documents = await Document.find({
+        project: project._id,
+        isDeleted: false,
+    }).lean()
+
+    const tree = buildTree(documents)
+
+    console.log(tree);
+    return NextResponse.json({
+        project: {
+            id: project._id.toString(),
+            name: project.name,
+            track: project.track,
+        },
+        tree,
+    })
+}
+

remote-ide/app/Api/projects/route.ts

@@ -0,0 +1,80 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { auth } from '@clerk/nextjs/server'
+import slugify from 'slugify'
+import { connectToDB } from '@/server/db/mongoose'
+import { Project, User } from '@/server/models/models'
+
+export async function GET(req: NextRequest) {
+    try {
+        await connectToDB();
+
+        const { userId } = await auth()
+        if (!userId) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+        }
+
+        const user = await User.findOne({ authId: userId })
+        if (!user) {
+            return NextResponse.json([], { status: 200 })
+        }
+
+        const projects = await Project.find({ owner: user._id })
+            .sort({ createdAt: -1 })
+            .select('_id name slug track createdAt')
+
+        return NextResponse.json(
+            projects.map(p => ({
+                id: p._id.toString(),
+                name: p.name,
+                slug: p.slug,
+                track: p.track,
+                createdAt: p.createdAt,
+            }))
+        )
+    }
+    catch {
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+    }
+}
+export async function PUT(req: NextRequest) {
+    try {
+
+        await connectToDB()
+        const { userId } = await auth()
+        if (!userId) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+        }
+
+        const { name, track } = await req.json()
+
+        const user = await User.findOne({ authId: userId })
+        if (!user) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 })
+        }
+
+        const project = await Project.create({
+            owner: user._id,
+            name,
+            track,
+            slug: slugify(name, { lower: true, strict: true }),
+        })
+
+        return NextResponse.json({
+            id: project._id.toString(),
+            name: project.name,
+            slug: project.slug,
+            track: project.track,
+            createdAt: project.createdAt,
+        })
+    } catch (err: any) {
+        if (err.code === 11000) {
+            return NextResponse.json(
+                { error: 'Project with same name already exists' },
+                { status: 409 }
+            )
+        }
+
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+    }
+}
+