streamby-core 0.28.4 → 0.28.6

package/dist/middleware/routes/renderFarm.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFarmRouter = renderFarmRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const jobQueue_1 = require("../../services/jobQueue");
+const vfxProcessor_1 = require("../../services/vfxProcessor");
+const crypto_1 = __importDefault(require("crypto"));
+function renderFarmRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // ─── Render Farm Connections ─────────────────────────────────────────────────
+    router.get('/projects/:projectId/render-farm-connections', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            res.json({ connections: project.renderFarmConnections ?? [] });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/render-farm-connections', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { name, provider, apiUrl, credentialId, description } = req.body;
+            if (!name || !provider || !apiUrl) {
+                return res.status(400).json({ message: 'name, provider and apiUrl are required' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const connection = {
+                id: crypto_1.default.randomUUID(),
+                name,
+                provider,
+                apiUrl,
+                credentialId,
+                description,
+                projectId,
+                createdAt: new Date(),
+            };
+            await Project.update({ _id: projectId }, { $push: { renderFarmConnections: connection } });
+            res.status(201).json({ connection });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/render-farm-connections/:connectionId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connectionId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            await Project.update({ _id: projectId }, { $pull: { renderFarmConnections: { id: connectionId } } });
+            res.json({ message: 'Connection deleted' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── VFX Jobs ────────────────────────────────────────────────────────────────
+    router.post('/projects/:projectId/jobs/render', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, renderer, renderFarmConnectionId, frameRange, resolution, samples, outputFormat } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('render', auth.userId, projectId, { fileId, renderer, renderFarmConnectionId, frameRange, resolution, samples, outputFormat });
+            setImmediate(() => (0, vfxProcessor_1.runRenderJob)(job.jobId, fileId, projectId, { renderer, renderFarmConnectionId, frameRange, resolution, samples, outputFormat }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/jobs/format-convert', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, inputFormat, outputFormat, applyTransforms, embedTextures } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('format-convert', auth.userId, projectId, { fileId, inputFormat, outputFormat, applyTransforms, embedTextures });
+            setImmediate(() => (0, vfxProcessor_1.runFormatConvertJob)(job.jobId, fileId, projectId, { inputFormat, outputFormat, applyTransforms, embedTextures }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/jobs/lod', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { fileId, levels, reductionRatios, algorithm, outputFormat } = req.body;
+            if (!fileId)
+                return res.status(400).json({ message: 'fileId is required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const job = (0, jobQueue_1.createJob)('lod', auth.userId, projectId, { fileId, levels, reductionRatios, algorithm, outputFormat });
+            setImmediate(() => (0, vfxProcessor_1.runLodJob)(job.jobId, fileId, projectId, { levels, reductionRatios, algorithm, outputFormat }));
+            res.status(202).json({ jobId: job.jobId, status: job.status });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── Asset Dependency Graph ──────────────────────────────────────────────────
+    router.get('/projects/:projectId/assets/:fileId/dependency-graph', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, fileId } = req.params;
+            const maxDepth = Number(req.query.maxDepth ?? 5);
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const graph = await (0, vfxProcessor_1.resolveAssetDependencyGraph)(projectId, fileId, maxDepth);
+            res.json({ graph });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/review.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import { StreamByConfig } from '../../types';
+export declare function reviewRouter(_config: StreamByConfig): Router;

package/dist/middleware/routes/review.js

@@ -0,0 +1,240 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewRouter = reviewRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const wsHub_1 = require("../../services/wsHub");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
+const crypto_1 = __importDefault(require("crypto"));
+function getDb() {
+    const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
+    if (!ids.length)
+        return null;
+    return (0, connectionManager_1.getConnection)(ids[0]).client.db();
+}
+function broadcastReviewUpdate(review, project) {
+    const members = project.members ?? [];
+    for (const m of members) {
+        (0, wsHub_1.emitToUser)(m.userId, { type: 'reviewEvent', data: review });
+    }
+}
+function reviewRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // GET /projects/:projectId/reviews
+    router.get('/projects/:projectId/reviews', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const reviews = await db.collection('review_sessions')
+                .find({ projectId })
+                .sort({ createdAt: -1 })
+                .toArray();
+            res.json({ reviews });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/reviews
+    router.post('/projects/:projectId/reviews', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { assetId, assetVersionId, requiredApprovers, deadline } = req.body;
+            if (!assetId || !assetVersionId) {
+                return res.status(400).json({ message: 'assetId and assetVersionId are required' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const now = new Date();
+            const review = {
+                id: crypto_1.default.randomUUID(),
+                projectId,
+                assetId,
+                assetVersionId,
+                status: 'open',
+                requiredApprovers: requiredApprovers ?? 1,
+                approvals: [],
+                deadline: deadline ? new Date(deadline) : undefined,
+                createdAt: now,
+                updatedAt: now,
+            };
+            await db.collection('review_sessions').insertOne({ ...review });
+            broadcastReviewUpdate(review, project);
+            res.status(201).json({ review });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // GET /projects/:projectId/reviews/:reviewId
+    router.get('/projects/:projectId/reviews/:reviewId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, reviewId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const review = await db.collection('review_sessions').findOne({ id: reviewId, projectId });
+            if (!review)
+                return res.status(404).json({ message: 'Review not found' });
+            res.json({ review });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // POST /projects/:projectId/reviews/:reviewId/decision
+    router.post('/projects/:projectId/reviews/:reviewId/decision', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, reviewId } = req.params;
+            const { decision, comment } = req.body;
+            if (decision !== 'approve' && decision !== 'reject') {
+                return res.status(400).json({ message: 'decision must be approve or reject' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const col = db.collection('review_sessions');
+            const review = await col.findOne({ id: reviewId, projectId });
+            if (!review)
+                return res.status(404).json({ message: 'Review not found' });
+            if (review.status !== 'open')
+                return res.status(409).json({ message: `Review is already ${review.status}` });
+            // Remove any prior decision from this user, then add the new one
+            const approvals = (review.approvals ?? []).filter(a => a.userId !== auth.userId);
+            approvals.push({
+                userId: auth.userId,
+                username: auth.username ?? auth.userId,
+                decision,
+                comment,
+                at: new Date(),
+            });
+            const approveCount = approvals.filter(a => a.decision === 'approve').length;
+            const hasRejection = approvals.some(a => a.decision === 'reject');
+            let status = 'open';
+            if (hasRejection)
+                status = 'rejected';
+            else if (approveCount >= review.requiredApprovers)
+                status = 'approved';
+            const updatedAt = new Date();
+            await col.updateOne({ id: reviewId, projectId }, { $set: { approvals, status, updatedAt } });
+            const updated = { ...review, approvals, status, updatedAt };
+            broadcastReviewUpdate(updated, project);
+            res.json({ review: updated });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    // ─── Annotations ─────────────────────────────────────────────────────────────
+    router.get('/projects/:projectId/assets/:assetId/versions/:versionId/annotations', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId, versionId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const annotations = await db.collection('annotations')
+                .find({ assetId, assetVersionId: versionId, projectId })
+                .sort({ createdAt: 1 })
+                .toArray();
+            res.json({ annotations });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.post('/projects/:projectId/assets/:assetId/versions/:versionId/annotations', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId, versionId } = req.params;
+            const { type, timecode, position3d, regionRect, text } = req.body;
+            if (!type || !text)
+                return res.status(400).json({ message: 'type and text are required' });
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            const annotation = {
+                id: crypto_1.default.randomUUID(),
+                assetId,
+                assetVersionId: versionId,
+                projectId,
+                authorId: auth.userId,
+                authorUsername: auth.username ?? auth.userId,
+                type,
+                timecode,
+                position3d,
+                regionRect,
+                text,
+                resolved: false,
+                createdAt: new Date(),
+            };
+            await db.collection('annotations').insertOne({ ...annotation });
+            res.status(201).json({ annotation });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    router.patch('/projects/:projectId/assets/:assetId/versions/:versionId/annotations/:annotationId/resolve', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, assetId, versionId, annotationId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = getDb();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            await db.collection('annotations').updateOne({ id: annotationId, assetId, assetVersionId: versionId, projectId }, { $set: { resolved: true, resolvedBy: auth.userId } });
+            res.json({ message: 'Annotation resolved' });
+        }
+        catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/storage.js

@@ -38,6 +38,14 @@ function getRawFilesCollection() {
         return null;
     return (0, connectionManager_1.getConnection)(activeId).client.db().collection('storage_files');
 }
+function getRawFoldersCollection() {
+    const model = (0, manager_1.getModel)('storage_files', 'nosql');
+    const connectionIds = model.getConnectionIds();
+    const activeId = connectionIds.find((id) => (0, connectionManager_1.getConnectedIds)().includes(id) && (0, connectionManager_1.getConnection)(id).type === 'nosql');
+    if (!activeId)
+        return null;
+    return (0, connectionManager_1.getConnection)(activeId).client.db().collection('storage_folders');
+}
 function connFilter(projectId, connId, extra) {
     const isBuiltin = connId === 'builtin' || connId.startsWith('builtin-');
     const connMatch = isBuiltin
@@ -460,6 +468,246 @@ function storageRouter(config) {
             res.status(500).json({ message: 'Failed to delete file', details: err.message });
         }
     });
+    // ─── Folder routes (per-connection) ─────────────────────────────────────
+    router.get('/projects/:projectId/connections/storage/:connId/folders', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId } = req.params;
+            const { parentId } = req.query;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            const collection = getRawFoldersCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const parentFilter = (parentId === undefined || parentId === 'null')
+                ? { parentId: null }
+                : { parentId };
+            const folders = await collection
+                .find(connFilter(projectId, connId, parentFilter))
+                .sort({ name: 1 })
+                .toArray();
+            res.json({
+                data: folders.map(f => ({
+                    id: f.folderId,
+                    name: f.name,
+                    parentId: f.parentId ?? null,
+                    projectId: f.projectId,
+                    storageConnectionId: f.storageConnectionId,
+                    createdBy: f.createdBy,
+                    createdAt: f.createdAt,
+                })),
+            });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to list folders', details: err.message });
+        }
+    });
+    router.get('/projects/:projectId/connections/storage/:connId/folders/:folderId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId, folderId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            const collection = getRawFoldersCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const f = await collection.findOne(connFilter(projectId, connId, { folderId }));
+            if (!f)
+                return res.status(404).json({ message: 'Folder not found' });
+            res.json({
+                folder: {
+                    id: f.folderId,
+                    name: f.name,
+                    parentId: f.parentId ?? null,
+                    projectId: f.projectId,
+                    storageConnectionId: f.storageConnectionId,
+                    createdBy: f.createdBy,
+                    createdAt: f.createdAt,
+                },
+            });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to get folder', details: err.message });
+        }
+    });
+    router.post('/projects/:projectId/connections/storage/:connId/folders', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId } = req.params;
+            const { name, parentId } = req.body;
+            if (!name || typeof name !== 'string' || !name.trim()) {
+                return res.status(400).json({ message: 'Folder name is required' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            const collection = getRawFoldersCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const folderId = crypto_1.default.randomUUID();
+            const isBuiltin = connId === 'builtin' || connId.startsWith('builtin-');
+            const folderDoc = {
+                _id: new mongodb_1.ObjectId(),
+                folderId,
+                projectId,
+                name: name.trim(),
+                parentId: parentId ?? null,
+                createdBy: auth.userId,
+                createdAt: new Date(),
+            };
+            if (!isBuiltin)
+                folderDoc.storageConnectionId = connId;
+            await collection.insertOne(folderDoc);
+            res.status(201).json({
+                message: 'Folder created successfully',
+                folder: {
+                    id: folderId,
+                    name: folderDoc.name,
+                    parentId: folderDoc.parentId,
+                    projectId,
+                    storageConnectionId: isBuiltin ? undefined : connId,
+                    createdBy: auth.userId,
+                    createdAt: folderDoc.createdAt,
+                },
+            });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to create folder', details: err.message });
+        }
+    });
+    router.patch('/projects/:projectId/connections/storage/:connId/folders/:folderId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId, folderId } = req.params;
+            const { name } = req.body;
+            if (!name || typeof name !== 'string' || !name.trim()) {
+                return res.status(400).json({ message: 'Folder name is required' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            const collection = getRawFoldersCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const result = await collection.findOneAndUpdate(connFilter(projectId, connId, { folderId }), { $set: { name: name.trim(), updatedAt: new Date() } }, { returnDocument: 'after' });
+            if (!result)
+                return res.status(404).json({ message: 'Folder not found' });
+            res.json({
+                message: 'Folder renamed successfully',
+                folder: {
+                    id: result.folderId,
+                    name: result.name,
+                    parentId: result.parentId ?? null,
+                    projectId: result.projectId,
+                    createdAt: result.createdAt,
+                },
+            });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to rename folder', details: err.message });
+        }
+    });
+    router.patch('/projects/:projectId/connections/storage/:connId/folders/:folderId/move', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId, folderId } = req.params;
+            const { newParentId } = req.body;
+            if (newParentId === folderId) {
+                return res.status(400).json({ message: 'A folder cannot be its own parent' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            const collection = getRawFoldersCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const result = await collection.findOneAndUpdate(connFilter(projectId, connId, { folderId }), { $set: { parentId: newParentId ?? null, updatedAt: new Date() } }, { returnDocument: 'after' });
+            if (!result)
+                return res.status(404).json({ message: 'Folder not found' });
+            res.json({
+                message: 'Folder moved successfully',
+                folder: {
+                    id: result.folderId,
+                    name: result.name,
+                    parentId: result.parentId ?? null,
+                    projectId: result.projectId,
+                    createdAt: result.createdAt,
+                },
+            });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to move folder', details: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/connections/storage/:connId/folders/:folderId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId, folderId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            const foldersCollection = getRawFoldersCollection();
+            if (!foldersCollection)
+                return res.status(500).json({ message: 'Database not available' });
+            const folderDoc = await foldersCollection.findOne(connFilter(projectId, connId, { folderId }));
+            if (!folderDoc)
+                return res.status(404).json({ message: 'Folder not found' });
+            const filesCollection = getRawFilesCollection();
+            if (filesCollection) {
+                await filesCollection.updateMany(connFilter(projectId, connId, { folderId }), { $set: { folderId: folderDoc.parentId ?? null } });
+            }
+            await foldersCollection.updateMany(connFilter(projectId, connId, { parentId: folderId }), { $set: { parentId: folderDoc.parentId ?? null } });
+            await foldersCollection.deleteOne(connFilter(projectId, connId, { folderId }));
+            res.json({ message: 'Folder deleted successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete folder', details: err.message });
+        }
+    });
+    router.patch('/projects/:projectId/connections/storage/:connId/files/:fileId/move', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId, fileId } = req.params;
+            const { folderId } = req.body;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            if (folderId != null) {
+                const foldersCollection = getRawFoldersCollection();
+                if (foldersCollection) {
+                    const folderDoc = await foldersCollection.findOne(connFilter(projectId, connId, { folderId }));
+                    if (!folderDoc)
+                        return res.status(404).json({ message: 'Folder not found' });
+                }
+            }
+            const filesCollection = getRawFilesCollection();
+            if (!filesCollection)
+                return res.status(500).json({ message: 'Database not available' });
+            const result = await filesCollection.findOneAndUpdate(connFilter(projectId, connId, { fileId }), { $set: { folderId: folderId ?? null } }, { returnDocument: 'after' });
+            if (!result)
+                return res.status(404).json({ message: 'File not found' });
+            res.json({ message: 'File moved successfully', file: result });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to move file', details: err.message });
+        }
+    });
     router.get('/storages', async (_req, res) => {
         try {
             const STORAGE_DISPLAY = {
@@ -496,6 +744,7 @@ async function resolveFileUrl(file, adapter) {
         contentType: file.contentType,
         uploadedBy: file.uploadedBy,
         createdAt: file.createdAt,
+        folderId: file.folderId ?? null,
         url,
     };
 }