File Upload Example #

// server.ts
import { createServer } from "verb";
import { cors, json, staticFiles } from "verb/middleware";
import { uploadRouter } from "./src/routes/upload";
import { fileRouter } from "./src/routes/files";
import { authRouter } from "./src/routes/auth";
import { FileStorage } from "./src/services/FileStorage";
import { ImageProcessor } from "./src/services/ImageProcessor";

const app = createServer();

// Initialize services
const fileStorage = new FileStorage();
const imageProcessor = new ImageProcessor();

// Middleware
app.use(cors({
  origin: ["http://localhost:3000"],
  credentials: true
}));
app.use(json({ limit: "50mb" })); // Large limit for base64 uploads

// Serve uploaded files
app.use("/uploads", staticFiles({ 
  root: "./uploads",
  maxAge: "1d",
  setHeaders: (res, path) => {
    // Add security headers for file serving
    res.header("X-Content-Type-Options", "nosniff");
    res.header("Content-Disposition", "inline");
  }
}));

// API routes
app.use("/api/auth", authRouter);
app.use("/api/upload", uploadRouter);
app.use("/api/files", fileRouter);

// Health check
app.get("/health", (req, res) => {
  res.json({ status: "healthy", storage: fileStorage.getStats() });
});

// File upload demo page
app.get("/", (req, res) => {
  res.sendFile("./public/index.html");
});

const port = process.env.PORT || 3000;
app.listen(port);

console.log(`🚀 File Upload Service running on port ${port}`);

// src/routes/upload.ts
import { createServer } from "verb";
import { multer } from "verb/middleware";
import { authenticate } from "../middleware/auth";
import { validateFile } from "../middleware/validation";
import { FileService } from "../services/FileService";
import { ImageProcessor } from "../services/ImageProcessor";
import { asyncHandler } from "../middleware/asyncHandler";

const uploadRouter = createServer();

// Configure multer for different upload types
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    const uploadDir = `./uploads/${new Date().getFullYear()}/${new Date().getMonth() + 1}`;
    cb(null, uploadDir);
  },
  filename: (req, file, cb) => {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    const ext = path.extname(file.originalname);
    cb(null, `${file.fieldname}-${uniqueSuffix}${ext}`);
  }
});

const upload = multer({
  storage,
  limits: {
    fileSize: 10 * 1024 * 1024, // 10MB limit
    files: 5 // Max 5 files
  },
  fileFilter: (req, file, cb) => {
    // Basic file type validation
    const allowedTypes = /jpeg|jpg|png|gif|pdf|doc|docx|txt|mp4|avi|mov/;
    const extname = allowedTypes.test(path.extname(file.originalname).toLowerCase());
    const mimetype = allowedTypes.test(file.mimetype);
    
    if (mimetype && extname) {
      return cb(null, true);
    } else {
      cb(new Error('Invalid file type'));
    }
  }
});

// Single file upload
uploadRouter.post("/single",
  authenticate,
  upload.single('file'),
  validateFile,
  asyncHandler(async (req, res) => {
    if (!req.file) {
      return res.status(400).json({ error: "No file uploaded" });
    }
    
    const userId = req.user.userId;
    const file = req.file;
    
    try {
      // Process and save file metadata
      const fileRecord = await FileService.create({
        userId,
        originalName: file.originalname,
        filename: file.filename,
        path: file.path,
        mimetype: file.mimetype,
        size: file.size,
        uploadType: "single"
      });
      
      // Process image if it's an image file
      if (file.mimetype.startsWith('image/')) {
        await ImageProcessor.generateThumbnails(fileRecord);
      }
      
      res.status(201).json({
        message: "File uploaded successfully",
        file: {
          id: fileRecord.id,
          originalName: fileRecord.originalName,
          size: fileRecord.size,
          mimetype: fileRecord.mimetype,
          url: `/uploads/${fileRecord.relativePath}`,
          thumbnails: fileRecord.thumbnails
        }
      });
    } catch (error) {
      console.error("File upload error:", error);
      res.status(500).json({ error: "Failed to process uploaded file" });
    }
  })
);

// Multiple file upload
uploadRouter.post("/multiple",
  authenticate,
  upload.array('files', 5),
  asyncHandler(async (req, res) => {
    if (!req.files || req.files.length === 0) {
      return res.status(400).json({ error: "No files uploaded" });
    }
    
    const userId = req.user.userId;
    const files = req.files as Express.Multer.File[];
    const results = [];
    
    for (const file of files) {
      try {
        const fileRecord = await FileService.create({
          userId,
          originalName: file.originalname,
          filename: file.filename,
          path: file.path,
          mimetype: file.mimetype,
          size: file.size,
          uploadType: "multiple"
        });
        
        // Process image thumbnails
        if (file.mimetype.startsWith('image/')) {
          await ImageProcessor.generateThumbnails(fileRecord);
        }
        
        results.push({
          id: fileRecord.id,
          originalName: fileRecord.originalName,
          size: fileRecord.size,
          mimetype: fileRecord.mimetype,
          url: `/uploads/${fileRecord.relativePath}`,
          thumbnails: fileRecord.thumbnails
        });
      } catch (error) {
        console.error(`Error processing file ${file.originalname}:`, error);
        results.push({
          originalName: file.originalname,
          error: "Failed to process file"
        });
      }
    }
    
    res.status(201).json({
      message: `${results.length} files processed`,
      files: results
    });
  })
);

// Base64 file upload
uploadRouter.post("/base64",
  authenticate,
  asyncHandler(async (req, res) => {
    const { filename, data, mimetype } = req.body;
    
    if (!filename || !data || !mimetype) {
      return res.status(400).json({ 
        error: "filename, data, and mimetype are required" 
      });
    }
    
    try {
      // Decode base64 data
      const buffer = Buffer.from(data, 'base64');
      
      // Validate file size
      if (buffer.length > 10 * 1024 * 1024) { // 10MB
        return res.status(413).json({ error: "File too large" });
      }
      
      // Save file
      const savedFile = await FileService.saveBase64File({
        userId: req.user.userId,
        filename,
        buffer,
        mimetype
      });
      
      // Process image if needed
      if (mimetype.startsWith('image/')) {
        await ImageProcessor.generateThumbnails(savedFile);
      }
      
      res.status(201).json({
        message: "File uploaded successfully",
        file: {
          id: savedFile.id,
          originalName: savedFile.originalName,
          size: savedFile.size,
          mimetype: savedFile.mimetype,
          url: `/uploads/${savedFile.relativePath}`,
          thumbnails: savedFile.thumbnails
        }
      });
    } catch (error) {
      console.error("Base64 upload error:", error);
      res.status(500).json({ error: "Failed to process base64 file" });
    }
  })
);

// Chunked upload initialization
uploadRouter.post("/chunk/init",
  authenticate,
  asyncHandler(async (req, res) => {
    const { filename, totalSize, chunkSize, mimetype } = req.body;
    
    if (!filename || !totalSize || !chunkSize || !mimetype) {
      return res.status(400).json({
        error: "filename, totalSize, chunkSize, and mimetype are required"
      });
    }
    
    try {
      const uploadSession = await FileService.initChunkedUpload({
        userId: req.user.userId,
        filename,
        totalSize,
        chunkSize,
        mimetype
      });
      
      res.json({
        uploadId: uploadSession.id,
        totalChunks: uploadSession.totalChunks,
        chunkSize: uploadSession.chunkSize
      });
    } catch (error) {
      console.error("Chunked upload init error:", error);
      res.status(500).json({ error: "Failed to initialize chunked upload" });
    }
  })
);

// Chunked upload - upload chunk
uploadRouter.post("/chunk/:uploadId/:chunkIndex",
  authenticate,
  upload.single('chunk'),
  asyncHandler(async (req, res) => {
    const { uploadId, chunkIndex } = req.params;
    
    if (!req.file) {
      return res.status(400).json({ error: "No chunk data uploaded" });
    }
    
    try {
      const result = await FileService.uploadChunk({
        uploadId,
        chunkIndex: parseInt(chunkIndex),
        chunkData: req.file.buffer || await Bun.file(req.file.path).arrayBuffer()
      });
      
      res.json({
        chunkIndex: parseInt(chunkIndex),
        uploaded: true,
        progress: result.progress,
        isComplete: result.isComplete,
        fileId: result.fileId
      });
    } catch (error) {
      console.error("Chunk upload error:", error);
      res.status(500).json({ error: "Failed to upload chunk" });
    }
  })
);

// Chunked upload - finalize
uploadRouter.post("/chunk/:uploadId/finalize",
  authenticate,
  asyncHandler(async (req, res) => {
    const { uploadId } = req.params;
    
    try {
      const finalizedFile = await FileService.finalizeChunkedUpload(uploadId);
      
      // Process image if needed
      if (finalizedFile.mimetype.startsWith('image/')) {
        await ImageProcessor.generateThumbnails(finalizedFile);
      }
      
      res.json({
        message: "Chunked upload completed successfully",
        file: {
          id: finalizedFile.id,
          originalName: finalizedFile.originalName,
          size: finalizedFile.size,
          mimetype: finalizedFile.mimetype,
          url: `/uploads/${finalizedFile.relativePath}`,
          thumbnails: finalizedFile.thumbnails
        }
      });
    } catch (error) {
      console.error("Finalize upload error:", error);
      res.status(500).json({ error: "Failed to finalize chunked upload" });
    }
  })
);

// Upload progress tracking
uploadRouter.get("/progress/:uploadId",
  authenticate,
  asyncHandler(async (req, res) => {
    const { uploadId } = req.params;
    
    try {
      const progress = await FileService.getUploadProgress(uploadId);
      res.json(progress);
    } catch (error) {
      res.status(404).json({ error: "Upload session not found" });
    }
  })
);

export { uploadRouter };

// src/routes/files.ts
import { createServer } from "verb";
import { authenticate } from "../middleware/auth";
import { FileService } from "../services/FileService";
import { ImageProcessor } from "../services/ImageProcessor";
import { asyncHandler } from "../middleware/asyncHandler";

const fileRouter = createServer();

// Get user's files
fileRouter.get("/",
  authenticate,
  asyncHandler(async (req, res) => {
    const userId = req.user.userId;
    const { page = 1, limit = 20, type, search } = req.query;
    
    const files = await FileService.getUserFiles({
      userId,
      page: parseInt(page),
      limit: parseInt(limit),
      type,
      search
    });
    
    res.json(files);
  })
);

// Get file by ID
fileRouter.get("/:id",
  authenticate,
  asyncHandler(async (req, res) => {
    const { id } = req.params;
    const userId = req.user.userId;
    
    const file = await FileService.getById(id);
    
    if (!file) {
      return res.status(404).json({ error: "File not found" });
    }
    
    // Check ownership or public access
    if (file.userId !== userId && !file.isPublic) {
      return res.status(403).json({ error: "Access denied" });
    }
    
    res.json({
      id: file.id,
      originalName: file.originalName,
      size: file.size,
      mimetype: file.mimetype,
      url: `/uploads/${file.relativePath}`,
      thumbnails: file.thumbnails,
      metadata: file.metadata,
      createdAt: file.createdAt
    });
  })
);

// Download file
fileRouter.get("/:id/download",
  authenticate,
  asyncHandler(async (req, res) => {
    const { id } = req.params;
    const userId = req.user.userId;
    
    const file = await FileService.getById(id);
    
    if (!file) {
      return res.status(404).json({ error: "File not found" });
    }
    
    // Check permissions
    if (file.userId !== userId && !file.isPublic) {
      return res.status(403).json({ error: "Access denied" });
    }
    
    // Update download count
    await FileService.incrementDownloadCount(id);
    
    // Set download headers
    res.header("Content-Disposition", `attachment; filename="${file.originalName}"`);
    res.header("Content-Type", file.mimetype);
    res.header("Content-Length", file.size.toString());
    
    // Stream file
    await res.sendFile(file.path);
  })
);

// Get file thumbnail
fileRouter.get("/:id/thumbnail/:size",
  asyncHandler(async (req, res) => {
    const { id, size } = req.params;
    
    const file = await FileService.getById(id);
    
    if (!file) {
      return res.status(404).json({ error: "File not found" });
    }
    
    if (!file.mimetype.startsWith('image/')) {
      return res.status(400).json({ error: "File is not an image" });
    }
    
    try {
      const thumbnailPath = await ImageProcessor.getThumbnail(file, size);
      
      res.header("Content-Type", "image/jpeg");
      res.header("Cache-Control", "public, max-age=31536000"); // 1 year
      
      await res.sendFile(thumbnailPath);
    } catch (error) {
      res.status(404).json({ error: "Thumbnail not found" });
    }
  })
);

// Update file metadata
fileRouter.patch("/:id",
  authenticate,
  asyncHandler(async (req, res) => {
    const { id } = req.params;
    const userId = req.user.userId;
    const updates = req.body;
    
    const file = await FileService.getById(id);
    
    if (!file) {
      return res.status(404).json({ error: "File not found" });
    }
    
    if (file.userId !== userId) {
      return res.status(403).json({ error: "Access denied" });
    }
    
    const updatedFile = await FileService.update(id, updates);
    
    res.json({
      message: "File updated successfully",
      file: updatedFile
    });
  })
);

// Delete file
fileRouter.delete("/:id",
  authenticate,
  asyncHandler(async (req, res) => {
    const { id } = req.params;
    const userId = req.user.userId;
    
    const file = await FileService.getById(id);
    
    if (!file) {
      return res.status(404).json({ error: "File not found" });
    }
    
    if (file.userId !== userId) {
      return res.status(403).json({ error: "Access denied" });
    }
    
    await FileService.delete(id);
    
    res.json({ message: "File deleted successfully" });
  })
);

// Share file (make public)
fileRouter.post("/:id/share",
  authenticate,
  asyncHandler(async (req, res) => {
    const { id } = req.params;
    const userId = req.user.userId;
    const { expiresAt } = req.body;
    
    const shareLink = await FileService.createShareLink({
      fileId: id,
      userId,
      expiresAt: expiresAt ? new Date(expiresAt) : undefined
    });
    
    res.json({
      message: "Share link created",
      shareLink: {
        id: shareLink.id,
        url: `/api/files/shared/${shareLink.token}`,
        expiresAt: shareLink.expiresAt
      }
    });
  })
);

// Access shared file
fileRouter.get("/shared/:token",
  asyncHandler(async (req, res) => {
    const { token } = req.params;
    
    try {
      const sharedFile = await FileService.getSharedFile(token);
      
      res.header("Content-Disposition", `inline; filename="${sharedFile.originalName}"`);
      res.header("Content-Type", sharedFile.mimetype);
      res.header("Cache-Control", "private, max-age=3600");
      
      await res.sendFile(sharedFile.path);
    } catch (error) {
      res.status(404).json({ error: "Shared file not found or expired" });
    }
  })
);

export { fileRouter };

// src/services/FileService.ts
import { Database } from "bun:sqlite";
import { promises as fs } from "fs";
import path from "path";
import { v4 as uuidv4 } from "uuid";
import mime from "mime-types";

const db = new Database("files.db");

// Initialize database
db.exec(`
  CREATE TABLE IF NOT EXISTS files (
    id TEXT PRIMARY KEY,
    user_id TEXT NOT NULL,
    original_name TEXT NOT NULL,
    filename TEXT NOT NULL,
    path TEXT NOT NULL,
    relative_path TEXT NOT NULL,
    mimetype TEXT NOT NULL,
    size INTEGER NOT NULL,
    upload_type TEXT DEFAULT 'single',
    is_public BOOLEAN DEFAULT FALSE,
    download_count INTEGER DEFAULT 0,
    metadata TEXT DEFAULT '{}',
    thumbnails TEXT DEFAULT '{}',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
  );
  
  CREATE TABLE IF NOT EXISTS upload_sessions (
    id TEXT PRIMARY KEY,
    user_id TEXT NOT NULL,
    filename TEXT NOT NULL,
    total_size INTEGER NOT NULL,
    chunk_size INTEGER NOT NULL,
    total_chunks INTEGER NOT NULL,
    mimetype TEXT NOT NULL,
    uploaded_chunks TEXT DEFAULT '[]',
    temp_dir TEXT NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
  );
  
  CREATE TABLE IF NOT EXISTS share_links (
    id TEXT PRIMARY KEY,
    file_id TEXT NOT NULL,
    user_id TEXT NOT NULL,
    token TEXT UNIQUE NOT NULL,
    expires_at DATETIME,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (file_id) REFERENCES files (id) ON DELETE CASCADE
  );
  
  CREATE INDEX IF NOT EXISTS idx_files_user_id ON files(user_id);
  CREATE INDEX IF NOT EXISTS idx_files_mimetype ON files(mimetype);
  CREATE INDEX IF NOT EXISTS idx_share_links_token ON share_links(token);
`);

export class FileService {
  static async create(fileData: {
    userId: string;
    originalName: string;
    filename: string;
    path: string;
    mimetype: string;
    size: number;
    uploadType?: string;
  }) {
    const id = uuidv4();
    const relativePath = path.relative('./uploads', fileData.path);
    
    db.query(`
      INSERT INTO files (
        id, user_id, original_name, filename, path, relative_path,
        mimetype, size, upload_type
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
    `).run(
      id,
      fileData.userId,
      fileData.originalName,
      fileData.filename,
      fileData.path,
      relativePath,
      fileData.mimetype,
      fileData.size,
      fileData.uploadType || 'single'
    );
    
    return this.getById(id);
  }
  
  static async saveBase64File(data: {
    userId: string;
    filename: string;
    buffer: Buffer;
    mimetype: string;
  }) {
    // Create upload directory
    const uploadDir = `./uploads/${new Date().getFullYear()}/${new Date().getMonth() + 1}`;
    await fs.mkdir(uploadDir, { recursive: true });
    
    // Generate unique filename
    const ext = mime.extension(data.mimetype) || 'bin';
    const uniqueFilename = `${Date.now()}-${Math.round(Math.random() * 1E9)}.${ext}`;
    const filePath = path.join(uploadDir, uniqueFilename);
    
    // Save file
    await fs.writeFile(filePath, data.buffer);
    
    return this.create({
      userId: data.userId,
      originalName: data.filename,
      filename: uniqueFilename,
      path: filePath,
      mimetype: data.mimetype,
      size: data.buffer.length,
      uploadType: 'base64'
    });
  }
  
  static async initChunkedUpload(data: {
    userId: string;
    filename: string;
    totalSize: number;
    chunkSize: number;
    mimetype: string;
  }) {
    const id = uuidv4();
    const totalChunks = Math.ceil(data.totalSize / data.chunkSize);
    const tempDir = `./temp/${id}`;
    
    await fs.mkdir(tempDir, { recursive: true });
    
    db.query(`
      INSERT INTO upload_sessions (
        id, user_id, filename, total_size, chunk_size, total_chunks,
        mimetype, temp_dir
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
    `).run(
      id,
      data.userId,
      data.filename,
      data.totalSize,
      data.chunkSize,
      totalChunks,
      data.mimetype,
      tempDir
    );
    
    return { id, totalChunks, chunkSize: data.chunkSize };
  }
  
  static async uploadChunk(data: {
    uploadId: string;
    chunkIndex: number;
    chunkData: ArrayBuffer;
  }) {
    const session = db.query(`
      SELECT * FROM upload_sessions WHERE id = ?
    `).get(data.uploadId) as any;
    
    if (!session) {
      throw new Error("Upload session not found");
    }
    
    // Save chunk
    const chunkPath = path.join(session.temp_dir, `chunk_${data.chunkIndex}`);
    await fs.writeFile(chunkPath, Buffer.from(data.chunkData));
    
    // Update uploaded chunks
    const uploadedChunks = JSON.parse(session.uploaded_chunks);
    uploadedChunks.push(data.chunkIndex);
    
    db.query(`
      UPDATE upload_sessions SET uploaded_chunks = ? WHERE id = ?
    `).run(JSON.stringify(uploadedChunks), data.uploadId);
    
    const progress = (uploadedChunks.length / session.total_chunks) * 100;
    const isComplete = uploadedChunks.length === session.total_chunks;
    
    return {
      progress,
      isComplete,
      fileId: isComplete ? await this.finalizeChunkedUpload(data.uploadId) : null
    };
  }
  
  static async finalizeChunkedUpload(uploadId: string) {
    const session = db.query(`
      SELECT * FROM upload_sessions WHERE id = ?
    `).get(uploadId) as any;
    
    if (!session) {
      throw new Error("Upload session not found");
    }
    
    // Create final upload directory
    const uploadDir = `./uploads/${new Date().getFullYear()}/${new Date().getMonth() + 1}`;
    await fs.mkdir(uploadDir, { recursive: true });
    
    // Generate final filename
    const ext = mime.extension(session.mimetype) || 'bin';
    const finalFilename = `${Date.now()}-${Math.round(Math.random() * 1E9)}.${ext}`;
    const finalPath = path.join(uploadDir, finalFilename);
    
    // Combine chunks
    const writeStream = Bun.file(finalPath).writer();
    
    for (let i = 0; i < session.total_chunks; i++) {
      const chunkPath = path.join(session.temp_dir, `chunk_${i}`);
      const chunkData = await fs.readFile(chunkPath);
      writeStream.write(chunkData);
    }
    
    await writeStream.end();
    
    // Create file record
    const fileRecord = await this.create({
      userId: session.user_id,
      originalName: session.filename,
      filename: finalFilename,
      path: finalPath,
      mimetype: session.mimetype,
      size: session.total_size,
      uploadType: 'chunked'
    });
    
    // Clean up temp files
    await fs.rm(session.temp_dir, { recursive: true, force: true });
    
    // Remove upload session
    db.query("DELETE FROM upload_sessions WHERE id = ?").run(uploadId);
    
    return fileRecord;
  }
  
  static async getById(id: string) {
    const file = db.query("SELECT * FROM files WHERE id = ?").get(id) as any;
    return file ? this.mapFileRecord(file) : null;
  }
  
  static async getUserFiles(options: {
    userId: string;
    page: number;
    limit: number;
    type?: string;
    search?: string;
  }) {
    let query = "SELECT * FROM files WHERE user_id = ?";
    const params = [options.userId];
    
    if (options.type) {
      query += " AND mimetype LIKE ?";
      params.push(`${options.type}/%`);
    }
    
    if (options.search) {
      query += " AND original_name LIKE ?";
      params.push(`%${options.search}%`);
    }
    
    // Count total
    const countQuery = query.replace("SELECT *", "SELECT COUNT(*) as count");
    const countResult = db.query(countQuery).get(...params) as any;
    const total = countResult.count;
    
    // Add pagination
    query += " ORDER BY created_at DESC LIMIT ? OFFSET ?";
    params.push(options.limit, (options.page - 1) * options.limit);
    
    const files = db.query(query).all(...params).map(this.mapFileRecord);
    
    return {
      files,
      pagination: {
        page: options.page,
        limit: options.limit,
        total,
        pages: Math.ceil(total / options.limit)
      }
    };
  }
  
  static async update(id: string, updates: any) {
    const allowedUpdates = ['original_name', 'is_public', 'metadata'];
    const setClause = [];
    const params = [];
    
    for (const [key, value] of Object.entries(updates)) {
      if (allowedUpdates.includes(key)) {
        setClause.push(`${key} = ?`);
        params.push(typeof value === 'object' ? JSON.stringify(value) : value);
      }
    }
    
    if (setClause.length === 0) {
      throw new Error("No valid updates provided");
    }
    
    setClause.push("updated_at = CURRENT_TIMESTAMP");
    params.push(id);
    
    db.query(`
      UPDATE files SET ${setClause.join(", ")} WHERE id = ?
    `).run(...params);
    
    return this.getById(id);
  }
  
  static async delete(id: string) {
    const file = await this.getById(id);
    if (!file) {
      throw new Error("File not found");
    }
    
    // Delete physical file
    try {
      await fs.unlink(file.path);
      
      // Delete thumbnails if they exist
      if (file.thumbnails) {
        for (const thumbnail of Object.values(file.thumbnails)) {
          try {
            await fs.unlink(thumbnail as string);
          } catch (e) {
            // Ignore thumbnail deletion errors
          }
        }
      }
    } catch (error) {
      console.error("Error deleting physical file:", error);
    }
    
    // Delete database record
    db.query("DELETE FROM files WHERE id = ?").run(id);
  }
  
  static async incrementDownloadCount(id: string) {
    db.query(`
      UPDATE files SET download_count = download_count + 1 WHERE id = ?
    `).run(id);
  }
  
  static async createShareLink(data: {
    fileId: string;
    userId: string;
    expiresAt?: Date;
  }) {
    const token = uuidv4();
    const id = uuidv4();
    
    db.query(`
      INSERT INTO share_links (id, file_id, user_id, token, expires_at)
      VALUES (?, ?, ?, ?, ?)
    `).run(id, data.fileId, data.userId, token, data.expiresAt?.toISOString());
    
    return { id, token, expiresAt: data.expiresAt };
  }
  
  static async getSharedFile(token: string) {
    const shareLink = db.query(`
      SELECT sl.*, f.* FROM share_links sl
      JOIN files f ON sl.file_id = f.id
      WHERE sl.token = ? AND (sl.expires_at IS NULL OR sl.expires_at > CURRENT_TIMESTAMP)
    `).get(token) as any;
    
    if (!shareLink) {
      throw new Error("Shared file not found or expired");
    }
    
    return this.mapFileRecord(shareLink);
  }
  
  static async getUploadProgress(uploadId: string) {
    const session = db.query(`
      SELECT * FROM upload_sessions WHERE id = ?
    `).get(uploadId) as any;
    
    if (!session) {
      throw new Error("Upload session not found");
    }
    
    const uploadedChunks = JSON.parse(session.uploaded_chunks);
    const progress = (uploadedChunks.length / session.total_chunks) * 100;
    
    return {
      uploadId,
      progress,
      uploadedChunks: uploadedChunks.length,
      totalChunks: session.total_chunks,
      isComplete: uploadedChunks.length === session.total_chunks
    };
  }
  
  private static mapFileRecord(file: any) {
    return {
      id: file.id,
      userId: file.user_id,
      originalName: file.original_name,
      filename: file.filename,
      path: file.path,
      relativePath: file.relative_path,
      mimetype: file.mimetype,
      size: file.size,
      uploadType: file.upload_type,
      isPublic: file.is_public,
      downloadCount: file.download_count,
      metadata: JSON.parse(file.metadata || '{}'),
      thumbnails: JSON.parse(file.thumbnails || '{}'),
      createdAt: file.created_at,
      updatedAt: file.updated_at
    };
  }
}