streamby-core 0.28.3 → 0.28.5

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
@@ -148,6 +156,39 @@ function storageRouter(config) {
             res.status(500).json({ message: 'Failed to generate upload URL', details: err.message });
         }
     });
+    router.get('/projects/:projectId/storage/files/:fileId/replace-url', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, fileId } = req.params;
+            const { contentType, fileName } = req.query;
+            if (!contentType || !fileName) {
+                return res.status(400).json({ message: 'Query params contentType and fileName 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 access' });
+            const collection = getRawFilesCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const fileDoc = await collection.findOne({ fileId, projectId });
+            if (!fileDoc)
+                return res.status(404).json({ message: 'File not found' });
+            if (!validateContentType(contentType, fileName, fileDoc.category)) {
+                return res.status(400).json({ message: `File does not match category ${fileDoc.category}` });
+            }
+            if (!adapter.getPresignedUploadUrl) {
+                return res.status(501).json({ message: 'Storage adapter does not support presigned uploads' });
+            }
+            const url = await adapter.getPresignedUploadUrl(fileDoc.storageKey, contentType);
+            await collection.updateOne({ fileId, projectId }, { $set: { contentType, updatedAt: new Date() } });
+            res.json({ url, storageKey: fileDoc.storageKey, fileId });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to generate replace URL', details: err.message });
+        }
+    });
     router.patch('/projects/:projectId/storage/files/:fileId', async (req, res) => {
         try {
             const auth = req.auth;
@@ -339,6 +380,42 @@ function storageRouter(config) {
             res.status(500).json({ message: 'Failed to list files', details: err.message });
         }
     });
+    router.get('/projects/:projectId/connections/storage/:connId/files/:fileId/replace-url', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId, fileId } = req.params;
+            const { contentType, fileName } = req.query;
+            if (!contentType || !fileName) {
+                return res.status(400).json({ message: 'Query params contentType and fileName 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 access' });
+            const collection = getRawFilesCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const fileDoc = await collection.findOne(connFilter(projectId, connId, { fileId }));
+            if (!fileDoc)
+                return res.status(404).json({ message: 'File not found' });
+            if (!validateContentType(contentType, fileName, fileDoc.category)) {
+                return res.status(400).json({ message: `File does not match category ${fileDoc.category}` });
+            }
+            const connAdapter = await resolveConnAdapter(connId, project, adapter);
+            if ('error' in connAdapter)
+                return res.status(connAdapter.status).json({ message: connAdapter.error });
+            if (!connAdapter.getPresignedUploadUrl) {
+                return res.status(501).json({ message: 'Storage adapter does not support presigned uploads' });
+            }
+            const url = await connAdapter.getPresignedUploadUrl(fileDoc.storageKey, contentType);
+            await collection.updateOne(connFilter(projectId, connId, { fileId }), { $set: { contentType, updatedAt: new Date() } });
+            res.json({ url, storageKey: fileDoc.storageKey, fileId });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to generate replace URL', details: err.message });
+        }
+    });
     router.patch('/projects/:projectId/connections/storage/:connId/files/:fileId', async (req, res) => {
         try {
             const auth = req.auth;
@@ -391,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 = {
@@ -427,6 +744,7 @@ async function resolveFileUrl(file, adapter) {
         contentType: file.contentType,
         uploadedBy: file.uploadedBy,
         createdAt: file.createdAt,
+        folderId: file.folderId ?? null,
         url,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamby-core",
-  "version": "0.28.3",
+  "version": "0.28.5",
   "description": "StreamBy middleware framework for media storage management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",