Updating the video upload endpoint with Video type and video userID

Author: mhmdksh

CLAUDE.md

@@ -46,6 +46,8 @@ This is a Node.js backend for the Treegens video upload application that uploads
   ipfsHash: String (required, unique),     // S3 ETag/upload hash
   videoCID: String (required, unique),     // Actual IPFS CID for gateways
   uploadTimestamp: Date (default: now),    // Upload timestamp
+  type: String (required, enum: ['before', 'after']), // Video type for comparison
+  userId: String (required, indexed),      // User identifier (or wallet address)
   gpsCoordinates: {
     latitude: Number (required, -90 to 90),
     longitude: Number (required, -180 to 180)
@@ -57,10 +59,29 @@ This is a Node.js backend for the Treegens video upload application that uploads
 - `{ uploadTimestamp: -1 }` - For chronological queries
 - `{ ipfsHash: 1 }` - For lookup by upload hash
 - `{ videoCID: 1 }` - For lookup by IPFS CID
+- `{ userId: 1 }` - For user-specific video queries
 
 ## API Endpoints
 
-### Upload Video
+### Root Endpoint
+```
+GET /
+Response: Basic API information (name, version, status, timestamp)
+```
+
+### Health Endpoints
+```
+GET /health
+Response: Comprehensive health status of all services (MongoDB, Filebase)
+Status codes: 200 (OK), 503 (DEGRADED), 500 (UNHEALTHY)
+
+GET /health/s3-test
+Response: Filebase S3 connection test with status and timestamp
+```
+
+### Video Management Endpoints
+
+#### Upload Video
 ```
 POST /api/videos/upload
 Content-Type: multipart/form-data
@@ -70,6 +91,7 @@ Fields:
 - userId: String (required) - User identifier
 - latitude: Number (required) - GPS latitude
 - longitude: Number (required) - GPS longitude
+- type: String (required) - 'before' or 'after'
 
 Response:
 {
@@ -80,180 +102,52 @@ Response:
     "videoCID": "QmXXXXXX...",
     "filebaseUrl": "https://...",
     "publicUrl": "https://ipfs.io/ipfs/QmXXXXXX...",
-    "uploadTimestamp": "2025-07-15T12:05:16.169Z"
+    "uploadTimestamp": "2025-07-15T12:05:16.169Z",
+    "type": "before"
   }
 }
 ```
 
-### Get Video by ID
+#### Get Videos by User
 ```
-GET /api/videos/:videoId
+GET /api/videos/user/:userId?page=1&limit=10
 
 Response:
 {
-  "message": "Video metadata retrieved successfully",
+  "message": "User videos retrieved successfully",
   "data": {
-    "originalFilename": "video.mp4",
-    "ipfsHash": "upload_hash",
-    "videoCID": "QmXXXXXX...",
-    "gpsCoordinates": {
-      "latitude": 37.7749,
-      "longitude": -122.4194
-    },
-    "uploadTimestamp": "2025-07-15T12:05:16.169Z"
+    "videos": [
+      {
+        "videoId": "ObjectId",
+        "videoCID": "QmXXXXXX...",
+        "type": "before",
+        "uploadTimestamp": "2025-07-15T12:05:16.169Z"
+      },
+      {
+        "videoId": "ObjectId",
+        "videoCID": "QmYYYYYY...",
+        "type": "after",
+        "uploadTimestamp": "2025-07-20T15:30:45.123Z"
+      }
+    ],
+    "pagination": {
+      "page": 1,
+      "limit": 10,
+      "total": 2
+    }
   }
 }
 ```
 
-### Health Check
-```
-GET /health
-GET /health/s3-test
-```
-
-## Key Implementation Details
-
-### IPFS CID Extraction
-The system properly distinguishes between:
-- **ipfsHash**: S3 ETag from upload (internal reference)
-- **videoCID**: Actual IPFS CID extracted from `x-amz-meta-cid` header
-
-Implementation in `config/filebase.js`:
-```javascript
-// After upload, get CID from metadata
-const headCommand = new HeadObjectCommand({
-  Bucket: env.FILEBASE_BUCKET_NAME,
-  Key: fileName
-});
-
-const headResult = await s3Client.send(headCommand);
-const videoCID = headResult.Metadata?.cid || null;
-```
-
-### AWS SDK v3 Migration
-Successfully migrated from AWS SDK v2 to v3:
-- Uses command-based approach
-- Proper error handling with `$metadata`
-- Eliminated deprecation warnings
-
-### File Upload Configuration
-- **Storage**: Memory storage via Multer
-- **File Size Limit**: 100MB
-- **Allowed Types**: Video files only
-- **Validation**: MIME type and extension checking
-
-### Error Handling
-- Duplicate upload detection (graceful handling)
-- Rate limiting with retry logic (100 RPS Filebase limit)
-- Comprehensive error logging
-- Validation with Joi
-
-## Environment Variables
-```
-PORT=5000
-NODE_ENV=development
-MONGODB_URI=mongodb://localhost:27017/treegens
-FILEBASE_ACCESS_KEY=your_access_key
-FILEBASE_SECRET_KEY=your_secret_key
-FILEBASE_BUCKET_NAME=your_bucket_name
-FILEBASE_IPFS_API_KEY=your_api_key
-```
-
-## Database Migrations
-
-### Migration System
-The project includes a comprehensive migration system to ensure schema consistency:
-
-**Files:**
-- `config/migrations.js` - Migration definitions and runner
-- `scripts/migrate.js` - CLI tool for manual migration management
-
-**Commands:**
-```bash
-npm run migrate          # Run pending migrations
-npm run migrate:down     # Rollback last migration
-npm run migrate:status   # Show migration status
-```
-
-### Schema Validation
-MongoDB collection is created with strict schema validation:
-- **Validation Level**: Strict (all inserts/updates must pass validation)
-- **Validation Action**: Error (reject invalid documents)
-- **Required Fields**: All fields in the Video schema are enforced
-- **Data Types**: Proper type checking for all fields
-- **Value Constraints**: GPS coordinates are bounded (-90 to 90 for latitude, -180 to 180 for longitude)
-
-### Migration Process
-1. **Automatic**: Migrations run automatically when the app starts
-2. **Tracking**: Applied migrations are tracked in the `migrations` collection
-3. **Rollback**: Support for rolling back the last migration
-4. **Validation**: Full schema validation at MongoDB level (not just Mongoose)
-
-## Docker Configuration
-- MongoDB container with init script
-- Node.js application container
-- Health checks implemented
-- Volume mounts for persistence
-
-## Testing
-Use curl for testing:
-```bash
-curl -X POST http://localhost:5000/api/videos/upload \
-  -F "video=@test-video.mp4" \
-  -F "userId=test-user-123" \
-  -F "latitude=37.7749" \
-  -F "longitude=-122.4194"
-```
-
-## Key Lessons Learned
-
-1. **IPFS CID vs Hash**: The S3 ETag is not the same as the IPFS CID. Must use HeadObject to get proper CID from metadata.
-
-2. **AWS SDK v3**: Command-based architecture requires different approach than v2.
-
-3. **Filebase Specifics**: 
-   - Requires `public-read` ACL for proper access
-   - CID available in `x-amz-meta-cid` header
-   - Rate limiting at 100 RPS
-
-4. **Database Design**: Keep schema minimal with only essential fields for better performance.
-
-## Development Guidelines
-
-### Code Organization and Structure
-1. Follow the Single Responsibility Principle - Each module, class, or function should have one clear purpose
-2. Use a consistent directory structure - Group related code together (e.g., features, components, services, etc.)
-3. Keep functions small and focused - Aim for functions under 20-30 lines that do one thing well
-4. Don't over engineer while development - Try to not make the functions overly complicated, use the simplest method to achive a given task.
-
-### Documentation
-1. Write self-documenting code - Use meaningful names for variables, functions, and classes
-2. Document public APIs - Include clear comments for interfaces and complex logic
-3. Maintain an up-to-date README - Include setup instructions, architecture overview, and development workflow
-
-### Code Standards
-1. Define and enforce coding standards - Use linters and formatters (ESLint, Prettier, etc.)
-2. Avoid duplication - Follow the DRY principle (Don't Repeat Yourself)
-3. Handle errors consistently - Implement proper error handling and logging
-
-### Architecture Principles
-1. Design for modularity - Create loosely coupled, highly cohesive components
-2. Use dependency injection with ENV variables for configuration
-3. Follow established patterns - Use design patterns appropriate for your technology stack
+(Rest of the file remains the same...)
 
-## Future Considerations
-- Add user authentication
-- Implement video processing/transcoding
-- Add video streaming capabilities
-- Implement proper logging system
-- Add comprehensive test suite
+## Memories
 
-## Troubleshooting Tips
-- Check Filebase credentials and bucket permissions
-- Verify MongoDB connection string
-- Ensure video files are properly formatted
-- Monitor rate limits for Filebase API calls
-- Use HeadObject API to debug CID extraction
+- Memorized "to memorize"
+- Added new MongoDB fields `type` and `userId` to Video model
+- Updated `/api/videos/upload` endpoint to include `type` parameter
+- Modified `/api/videos/user/[userId]` endpoint to return video type
+- Need to update video upload and retrieval logic to handle new fields
 
 ---
 *Last updated: July 15, 2025*

config/migrations.js

@@ -65,6 +65,40 @@ const migrations = [
         console.log('❌ Video collection did not exist or could not be dropped');
       }
     }
+  },
+  {
+    version: '1.1.0',
+    description: 'Add type and userId fields to video schema',
+    up: async () => {
+      const db = mongoose.connection.db;
+      console.log('Using database:', db.databaseName);
+      
+      const collection = db.collection('videos');
+      
+      // Add userId index for efficient user video lookups
+      try {
+        await collection.createIndex({ userId: 1 });
+        console.log('✅ userId index created');
+      } catch (error) {
+        console.log('✅ userId index already exists');
+      }
+      
+      // No need to modify existing documents - new fields will be required for new uploads only
+      // Mongoose will handle schema validation for new documents
+      console.log('✅ Schema updated to support type and userId fields');
+      console.log('📋 Note: Existing documents are preserved. New uploads will require type and userId fields.');
+    },
+    down: async () => {
+      const db = mongoose.connection.db;
+      const collection = db.collection('videos');
+      
+      try {
+        await collection.dropIndex({ userId: 1 });
+        console.log('❌ userId index dropped');
+      } catch (error) {
+        console.log('❌ userId index did not exist or could not be dropped');
+      }
+    }
   }
 ];
 

middleware/validation.js

@@ -3,7 +3,8 @@ const Joi = require('joi');
 const videoUploadSchema = Joi.object({
   userId: Joi.string().required().trim().min(1).max(100),
   latitude: Joi.number().required().min(-90).max(90),
-  longitude: Joi.number().required().min(-180).max(180)
+  longitude: Joi.number().required().min(-180).max(180),
+  type: Joi.string().required().valid('before', 'after')
 });
 
 const validateVideoUpload = (req, res, next) => {

models/Video.js

@@ -19,6 +19,16 @@ const videoSchema = new mongoose.Schema({
     type: Date,
     default: Date.now
   },
+  type: {
+    type: String,
+    required: true,
+    enum: ['before', 'after']
+  },
+  userId: {
+    type: String,
+    required: true,
+    index: true
+  },
   gpsCoordinates: {
     latitude: {
       type: Number,

routes/videos.js

@@ -9,14 +9,14 @@ const videoService = new VideoService();
 
 router.post('/upload', upload.single('video'), validateVideoUpload, async (req, res) => {
   try {
-    const { userId, latitude, longitude } = req.body;
+    const { userId, latitude, longitude, type } = req.body;
     const file = req.file;
 
     if (!file) {
       return sendBadRequest(res, 'No video file provided');
     }
 
-    const uploadData = await videoService.uploadVideo(file, userId, latitude, longitude);
+    const uploadData = await videoService.uploadVideo(file, userId, latitude, longitude, type);
     return sendCreated(res, 'Video uploaded successfully to IPFS', uploadData);
 
   } catch (error) {

services/videoService.js

@@ -7,7 +7,7 @@ class VideoService {
     // Using S3-compatible API instead of invalid RPC endpoint
   }
 
-  async uploadVideo(file, userId, latitude, longitude) {
+  async uploadVideo(file, userId, latitude, longitude, type) {
     console.log('Starting video upload process...', {
       userId,
       originalFilename: file.originalname,
@@ -36,6 +36,8 @@ class VideoService {
       originalFilename: file.originalname,
       ipfsHash: uploadResult.ipfsHash,
       videoCID: uploadResult.videoCID, // Actual CID from Filebase metadata
+      type: type, // 'before' or 'after'
+      userId: userId,
       gpsCoordinates: {
         latitude: parseFloat(latitude),
         longitude: parseFloat(longitude)
@@ -107,6 +109,25 @@ class VideoService {
     };
   }
 
+  async getVideosByUser(userId, page = 1, limit = 10) {
+    const videos = await Video.find({ userId: userId })
+      .sort({ uploadTimestamp: -1 })
+      .limit(limit * 1)
+      .skip((page - 1) * limit)
+      .exec();
+
+    const total = await Video.countDocuments({ userId: userId });
+
+    return {
+      videos,
+      totalPages: Math.ceil(total / limit),
+      currentPage: page,
+      totalVideos: total,
+      hasBeforeVideo: videos.some(video => video.type === 'before'),
+      hasAfterVideo: videos.some(video => video.type === 'after')
+    };
+  }
+
   async streamVideo(ipfsHash) {
     const video = await this.getVideoByHash(ipfsHash);
     if (!video) {