streamby-core 0.26.4 → 0.26.6

package/dist/middleware/createRouter.js

@@ -8,19 +8,19 @@ const express_1 = __importDefault(require("express"));
 const manager_1 = require("../models/manager");
 const storage_1 = require("../providers/storage");
 const connectionManager_1 = require("../adapters/database/connectionManager");
-const auth_1 = require("./routes/auth");
-const database_1 = require("./routes/database");
+const wsHub_1 = require("../services/wsHub");
+const auth_1 = require("../services/auth");
+const encryption_1 = require("../utils/encryption");
+const auth_2 = require("./routes/auth");
+const user_1 = require("./routes/user");
+const export_1 = require("./routes/export");
+const member_1 = require("./routes/member");
 const storage_2 = require("./routes/storage");
 const project_1 = require("./routes/project");
-const export_1 = require("./routes/export");
+const database_1 = require("./routes/database");
 const credential_1 = require("./routes/credential");
 const connection_1 = require("./routes/connection");
-const member_1 = require("./routes/member");
-const user_1 = require("./routes/user");
 const notification_1 = require("./routes/notification");
-const auth_2 = require("../services/auth");
-const encryption_1 = require("../utils/encryption");
-const wsHub_1 = require("../services/wsHub");
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
     if (config.encrypt)
@@ -29,13 +29,13 @@ function createStreamByRouter(config) {
     const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
     if (config.databases) {
         const allDbIds = config.databases.map(db => db.id);
-        const sqlDbs = config.databases.filter(db => db.type === 'sql');
-        const streambySchema = sqlDbs.length > 0 ? 'streamby' : undefined;
-        (0, manager_1.registerModel)('projects', allDbIds, 'projects', streambySchema);
+        const streambySchema = 'streamby';
         (0, manager_1.registerModel)('exports', allDbIds, 'exports', streambySchema);
+        (0, manager_1.registerModel)('projects', allDbIds, 'projects', streambySchema);
         const nosqlDbIds = config.databases.filter(db => db.type === 'nosql').map(db => db.id);
         if (nosqlDbIds.length > 0) {
-            (0, manager_1.registerModel)('notifications', nosqlDbIds, 'notifications');
+            (0, manager_1.registerModel)('notifications', nosqlDbIds, 'notifications', streambySchema);
+            (0, manager_1.registerModel)('storage_files', nosqlDbIds, 'storage_files');
         }
         const mainDb = config.databases.find(db => db.main);
         if (mainDb) {
@@ -45,16 +45,16 @@ function createStreamByRouter(config) {
     if (config.websocket?.server) {
         (0, wsHub_1.initWsHub)(config.websocket.server, config, config.websocket.path);
     }
-    router.use((0, auth_2.authenticate)(config));
-    router.use((0, auth_1.authRouter)(config));
-    router.use((0, database_1.databaseRouter)(config));
+    router.use((0, user_1.userRouter)(config));
+    router.use((0, auth_2.authRouter)(config));
+    router.use((0, auth_1.authenticate)(config));
+    router.use((0, export_1.exportRouter)(config));
+    router.use((0, member_1.memberRouter)(config));
     router.use((0, storage_2.storageRouter)(config));
     router.use((0, project_1.projectRouter)(config));
-    router.use((0, export_1.exportRouter)(config));
+    router.use((0, database_1.databaseRouter)(config));
     router.use((0, credential_1.credentialRouter)(config));
-    router.use((0, connection_1.apiConnectionRouter)(config));
-    router.use((0, member_1.memberRouter)(config));
-    router.use((0, user_1.userRouter)(config));
+    router.use((0, connection_1.connectionRouter)(config));
     router.use((0, notification_1.notificationRouter)(config));
     return router;
 }

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

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

package/dist/middleware/routes/connection.js

@@ -33,13 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.apiConnectionRouter = apiConnectionRouter;
+exports.connectionRouter = connectionRouter;
 const express_1 = require("express");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const apiConnection_1 = require("../../services/apiConnection");
 const VALID_METHODS = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE'];
-function apiConnectionRouter(config) {
+function connectionRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
     // List API connections for a project

package/dist/middleware/routes/export.js

@@ -9,6 +9,37 @@ const pipeline_1 = require("../../services/pipeline");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
 const mongodb_1 = require("mongodb");
 const encryption_1 = require("../../utils/encryption");
+const DEFAULT_NODE_SCHEMA = {
+    nodes: [
+        {
+            id: 'client',
+            type: 'clientNode',
+            position: { x: 0, y: 100 },
+            data: { label: 'Client', subtitle: 'GET' },
+            width: 148,
+            height: 100,
+        },
+        {
+            id: 'streamby',
+            type: 'streambyNode',
+            position: { x: 240, y: 100 },
+            data: { label: 'StreamBy', subtitle: 'Middleware' },
+            width: 158,
+            height: 100,
+        },
+    ],
+    edges: [
+        {
+            id: 'e-client-streamby',
+            source: 'client',
+            sourceHandle: 'out-right',
+            target: 'streamby',
+            targetHandle: 'in-left',
+            animated: true,
+            style: { stroke: '#38B6FF', strokeWidth: 2 },
+        },
+    ],
+};
 function exportRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
@@ -162,15 +193,13 @@ function exportRouter(config) {
             if (!name) {
                 return res.status(400).json({ message: 'Missing export name' });
             }
-            if (!nodeSchema) {
-                return res.status(400).json({ message: 'Missing nodeSchema' });
-            }
+            const resolvedNodeSchema = nodeSchema ?? DEFAULT_NODE_SCHEMA;
             const exportType = useConnections ? 'externalApi' : 'json';
             const project = await Project.findOne({ _id: projectId });
             if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            const result = await (0, export_1.createExport)(config, projectId, description, name, project.dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials);
+            const result = await (0, export_1.createExport)(config, projectId, description, name, project.dbType, exportType, isPrivate, allowedOrigin, resolvedNodeSchema, useConnections, useCredentials);
             res.status(201).json({ data: result, message: result.message });
         }
         catch (err) {
@@ -185,13 +214,6 @@ function exportRouter(config) {
             }
             const { id: projectId, export_id: exportId } = req.params;
             const { name, description, isPrivate, allowedOrigin, useConnections, useCredentials, nodeSchema } = req.body;
-            if (!name) {
-                return res.status(400).json({ message: 'Missing name' });
-            }
-            if (!nodeSchema) {
-                return res.status(400).json({ message: 'Missing nodeSchema' });
-            }
-            const exportType = useConnections ? 'externalApi' : 'json';
             const project = await Project.findOne({ _id: projectId });
             if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
@@ -200,7 +222,11 @@ function exportRouter(config) {
             if (!exportMetadata) {
                 return res.status(404).json({ message: 'Export not found' });
             }
-            const result = await (0, export_1.updateExport)(config, projectId, exportId, description, name, project.dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials);
+            const resolvedName = name ?? exportMetadata.name;
+            const resolvedNodeSchema = nodeSchema ?? exportMetadata.nodeSchema;
+            const resolvedUseConnections = useConnections ?? exportMetadata.useConnections;
+            const exportType = resolvedUseConnections ? 'externalApi' : 'json';
+            const result = await (0, export_1.updateExport)(config, projectId, exportId, description ?? exportMetadata.description, resolvedName, project.dbType, exportType, isPrivate ?? exportMetadata.private, allowedOrigin ?? exportMetadata.allowedOrigin, resolvedNodeSchema, resolvedUseConnections, useCredentials ?? exportMetadata.useCredentials);
             res.status(200).json({ data: result, message: result.message });
         }
         catch (err) {

package/dist/middleware/routes/member.js

@@ -32,14 +32,15 @@ function memberRouter(config) {
             if (!mainDb) {
                 return res.status(500).json({ message: 'Main database not configured' });
             }
-            const User = (0, manager_1.getModel)('users');
+            const User = (0, manager_1.getModel)('users', mainDb.type);
             const membersWithUsernames = await Promise.all(project.members.map(async (member) => {
                 const user = await User.findOne({ _id: member.userId });
                 return {
                     userId: member.userId,
                     username: user ? user.username : 'Unknown',
                     role: member.role,
-                    profilePic: user ? user.profilePic : '',
+                    status: member.status,
+                    profilePic: user ? user.profilePic : user.googlePic,
                 };
             }));
             res.json({ members: membersWithUsernames, message: 'Project members fetched successfully' });
@@ -96,7 +97,7 @@ function memberRouter(config) {
             else {
                 await Project.update({ _id: projectId }, { $push: { members: newMember } });
             }
-            await (0, notification_1.createNotification)(userId, 'member_invited', `Te invitaron al proyecto "${project.name}"`, { projectId, role, invitedBy: auth.userId });
+            await (0, notification_1.createNotification)(userId, 'member_invited', `You has been invited to join the project "${project.name}"`, { projectId, role, invitedBy: auth.userId });
             res.status(201).json({ member: newMember, message: 'Member invited successfully' });
         }
         catch (err) {

package/dist/middleware/routes/notification.js

@@ -3,14 +3,58 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.notificationRouter = notificationRouter;
 const express_1 = require("express");
 const manager_1 = require("../../models/manager");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
+const mongodb_1 = require("mongodb");
+const MAX_NOTIFICATIONS = 20;
+function getRawNotifCollection() {
+    const model = (0, manager_1.getModel)('notifications', '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('notifications');
+}
 function notificationRouter(config) {
     const router = (0, express_1.Router)();
-    const Notification = (0, manager_1.getModel)('notifications');
     router.get('/notifications', async (req, res) => {
         try {
             const auth = req.auth;
-            const notifications = await Notification.find({ userId: auth.userId, read: false });
-            res.status(200).json({ data: notifications });
+            const limit = Math.min(parseInt(req.query.limit) || MAX_NOTIFICATIONS, MAX_NOTIFICATIONS);
+            const page = Math.max(parseInt(req.query.page) || 1, 1);
+            const skip = (page - 1) * limit;
+            const appIdQuery = req.query.appId;
+            const collection = getRawNotifCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const filter = { userId: auth.userId.toString() };
+            if (appIdQuery !== undefined) {
+                filter.appId = appIdQuery === '0' ? null : appIdQuery;
+            }
+            const total = await collection.countDocuments(filter);
+            const notifications = await collection
+                .find(filter)
+                .sort({ createdAt: -1 })
+                .skip(skip)
+                .limit(limit)
+                .toArray();
+            res.status(200).json({
+                data: notifications,
+                pagination: { page, limit, total, pages: Math.ceil(total / limit) },
+            });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch notifications', details: err.message });
+        }
+    });
+    router.get('/notifications/:id', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { id } = req.params;
+            const notifications = (0, manager_1.getModel)('notifications', 'nosql');
+            const notification = await notifications.findOne({ _id: new mongodb_1.ObjectId(id), userId: auth.userId.toString() });
+            res.status(200).json({
+                data: notification,
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to fetch notifications', details: err.message });
@@ -19,10 +63,15 @@ function notificationRouter(config) {
     router.patch('/notifications/read-all', async (req, res) => {
         try {
             const auth = req.auth;
-            const model = Notification;
-            if (model.updateMany) {
-                await model.updateMany({ userId: auth.userId, read: false }, { $set: { read: true, readAt: new Date() } });
+            const appIdQuery = req.query.appId;
+            const collection = getRawNotifCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const filter = { userId: auth.userId.toString(), read: false };
+            if (appIdQuery !== undefined) {
+                filter.appId = appIdQuery === '0' ? null : appIdQuery;
             }
+            await collection.updateMany(filter, { $set: { read: true, readAt: new Date() } });
             res.status(200).json({ message: 'All notifications marked as read' });
         }
         catch (err) {
@@ -33,7 +82,10 @@ function notificationRouter(config) {
         try {
             const auth = req.auth;
             const { id } = req.params;
-            await Notification.update({ _id: id, userId: auth.userId }, { read: true, readAt: new Date() });
+            const collection = getRawNotifCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            await collection.updateOne({ _id: new mongodb_1.ObjectId(id), userId: auth.userId.toString() }, { $set: { read: true, readAt: new Date() } });
             res.status(200).json({ message: 'Notification marked as read' });
         }
         catch (err) {

package/dist/middleware/routes/project.js

@@ -6,10 +6,8 @@ const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
 const sql_1 = require("../../adapters/database/sql");
-const auth_2 = require("../../services/auth");
 function projectRouter(config) {
     const router = (0, express_1.Router)();
-    router.use((0, auth_2.authenticate)(config));
     const Project = (0, manager_1.getModel)('projects');
     const mapProjectToResponseFormat = (project, userId) => {
         const currentUserMember = project.members?.find((member) => member.userId === userId);
@@ -29,12 +27,11 @@ function projectRouter(config) {
             const allProjects = await Project.find({}); // Fetch all projects
             const projects = allProjects
                 .filter(project => {
-                const isMember = project.members?.some((m) => m.userId?.toString() === auth.userId?.toString());
-                if (!isMember)
+                const currentUserMember = project.members?.find((m) => m.userId?.toString() === auth.userId?.toString());
+                if (!currentUserMember || currentUserMember.status !== 'active')
                     return false;
                 if (filterArchived !== undefined) {
-                    const currentUserMember = project.members?.find((member) => member.userId === auth.userId);
-                    return currentUserMember ? (currentUserMember.archived || false) === filterArchived : false;
+                    return (currentUserMember.archived || false) === filterArchived;
                 }
                 return true;
             })
@@ -69,13 +66,15 @@ function projectRouter(config) {
                 description: description || '',
                 image: image || '',
                 allowedOrigin: allowedOrigin || [],
-                members: [{ userId: auth.userId, username: user.username, role: "admin", archived: false }],
+                members: [{ userId: auth.userId, username: user.username, role: "admin", status: "active", archived: false }],
             });
             const allProjects = await Project.find({});
             const projects = allProjects
                 .filter(project => {
-                const isMember = project.members?.some((m) => m.userId?.toString() === auth.userId?.toString());
-                return isMember; // Only include projects where the user is a member
+                const currentUserMember = project.members?.find((m) => m.userId?.toString() === auth.userId?.toString());
+                if (!currentUserMember || currentUserMember.status !== 'active')
+                    return false;
+                return true;
             })
                 .map(project => mapProjectToResponseFormat(project, auth.userId));
             res.status(200).json({ success: true, projects: projects, projectId: newProject._id || newProject.id, message: 'Project created successfully' });
@@ -85,6 +84,38 @@ function projectRouter(config) {
             res.status(500).json({ message: 'Failed to create project', details: err.message });
         }
     });
+    router.get('/projects/:id/preview', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const projectId = req.params.id;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project) {
+                return res.status(404).json({ message: 'Project not found' });
+            }
+            const currentMember = project.members?.find((m) => m.userId?.toString() === auth.userId?.toString());
+            const membership = currentMember
+                ? { isMember: true, status: currentMember.status || 'active' }
+                : { isMember: false, status: null };
+            res.json({
+                membership,
+                project: {
+                    id: project._id || project.id,
+                    name: project.name,
+                    description: project.description || '',
+                    image: project.image || '',
+                    dbType: project.dbType,
+                    members: (project.members || [])
+                        .filter((m) => !m.archived)
+                        .map((m) => ({ role: m.role })),
+                    exports: (project.exports || []).map((e) => ({ method: e.method })),
+                },
+                message: 'Project preview fetched successfully',
+            });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch project preview', details: err.message });
+        }
+    });
     router.get('/projects/:id', async (req, res) => {
         try {
             const auth = req.auth;
@@ -136,8 +167,10 @@ function projectRouter(config) {
             const allProjects = await Project.find({});
             const projects = allProjects
                 .filter(project => {
-                const isMember = project.members?.some((m) => m.userId?.toString() === auth.userId?.toString());
-                return isMember; // Only include projects where the user is a member
+                const currentUserMember = project.members?.find((m) => m.userId?.toString() === auth.userId?.toString());
+                if (!currentUserMember || currentUserMember.status !== 'active')
+                    return false;
+                return true;
             })
                 .map(project => mapProjectToResponseFormat(project, auth.userId));
             res.status(200).json({ success: true, projects: projects, projectId: updated._id || updated.id, message: 'Project updated successfully' });
@@ -160,11 +193,13 @@ function projectRouter(config) {
             await Project.useDbType(project.dbType).delete({ _id: projectId });
             const allProjects = await Project.find({});
             const projects = allProjects
-                .filter(p => {
-                const isMember = p.members?.some((m) => m.userId?.toString() === auth.userId?.toString());
-                return isMember; // Only include projects where the user is a member
+                .filter(project => {
+                const currentUserMember = project.members?.find((m) => m.userId?.toString() === auth.userId?.toString());
+                if (!currentUserMember || currentUserMember.status !== 'active')
+                    return false;
+                return true;
             })
-                .map(p => mapProjectToResponseFormat(p, auth.userId));
+                .map(project => mapProjectToResponseFormat(project, auth.userId));
             res.status(200).json({ success: true, projects: projects, message: 'Project deleted successfully' });
         }
         catch (err) {
@@ -197,8 +232,10 @@ function projectRouter(config) {
             const allProjects = await Project.find({});
             const projects = allProjects
                 .filter(project => {
-                const isMember = project.members?.some((m) => m.userId?.toString() === auth.userId?.toString());
-                return isMember; // Only include projects where the user is a member
+                const currentUserMember = project.members?.find((m) => m.userId?.toString() === auth.userId?.toString());
+                if (!currentUserMember || currentUserMember.status !== 'active')
+                    return false;
+                return true;
             })
                 .map(project => mapProjectToResponseFormat(project, auth.userId));
             res.status(200).json({ success: true, projects: projects, message: 'Project archived successfully' });
@@ -233,8 +270,10 @@ function projectRouter(config) {
             const allProjects = await Project.find({});
             const projects = allProjects
                 .filter(project => {
-                const isMember = project.members?.some((m) => m.userId?.toString() === auth.userId?.toString());
-                return isMember; // Only include projects where the user is a member
+                const currentUserMember = project.members?.find((m) => m.userId?.toString() === auth.userId?.toString());
+                if (!currentUserMember || currentUserMember.status !== 'active')
+                    return false;
+                return true;
             })
                 .map(project => mapProjectToResponseFormat(project, auth.userId));
             res.status(200).json({ success: true, projects: projects, message: 'Project unarchived successfully' });

package/dist/middleware/routes/storage.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.storageRouter = storageRouter;
 const express_1 = require("express");
@@ -6,7 +9,10 @@ const file_1 = require("../../services/file");
 const presign_1 = require("../../services/presign");
 const storage_1 = require("../../providers/storage");
 const manager_1 = require("../../models/manager");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
 const auth_1 = require("../../utils/auth");
+const mongodb_1 = require("mongodb");
+const crypto_1 = __importDefault(require("crypto"));
 const VALID_CATEGORIES = ['images', 'audios', 'videos', '3d-models'];
 const VALID_3D_EXTENSIONS = new Set(['.glb', '.gltf', '.obj', '.fbx', '.stl', '.ply']);
 function validateContentType(contentType, filename, category) {
@@ -22,11 +28,13 @@ function validateContentType(contentType, filename, category) {
     }
     return false;
 }
-function sanitizeFilename(filename) {
-    const dotIndex = filename.lastIndexOf('.');
-    const ext = dotIndex !== -1 ? filename.slice(dotIndex) : '';
-    const base = (dotIndex !== -1 ? filename.slice(0, dotIndex) : filename).replace(/[^a-zA-Z0-9._-]/g, '_');
-    return `${base}${ext}`;
+function getRawFilesCollection() {
+    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_files');
 }
 function storageRouter(config) {
     const router = (0, express_1.Router)();
@@ -34,19 +42,12 @@ function storageRouter(config) {
     const Project = (0, manager_1.getModel)('projects');
     router.get('/upload-project-image-url/:id', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth ||
-                !auth.userId ||
-                !auth.role) {
-                return res.status(401).json({ message: 'Unauthorized' });
-            }
-            if (auth.role !== 'admin' && auth.role !== 'editor') {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor')
                 return res.status(403).json({ message: 'Permission denied' });
-            }
             const projectId = req.params.id;
-            if (!projectId) {
+            if (!projectId)
                 return res.status(400).json({ message: 'Missing projectId' });
-            }
             const response = await (0, presign_1.getPresignedProjectImageUrl)(adapter, projectId);
             res.status(200).json({ ...response, message: 'Presigned URL generated successfully' });
         }
@@ -56,19 +57,12 @@ function storageRouter(config) {
     });
     router.delete('/delete-project-image-url/:id', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth ||
-                !auth.userId ||
-                !auth.role) {
-                return res.status(401).json({ message: 'Unauthorized' });
-            }
-            if (auth.role !== 'admin' && auth.role !== 'editor') {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor')
                 return res.status(403).json({ message: 'Permission denied' });
-            }
             const projectId = req.params.id;
-            if (!projectId) {
+            if (!projectId)
                 return res.status(400).json({ message: 'Missing projectId' });
-            }
             await (0, file_1.deleteProjectImage)(adapter, projectId);
             const updated = await Project.update({ _id: projectId }, { image: '' });
             res.status(201).json({ ...updated, message: 'Image deleted successfully' });
@@ -79,10 +73,7 @@ function storageRouter(config) {
     });
     router.get('/projects/:projectId/storage/:category/upload-url', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth || !auth.userId || !auth.role) {
-                return res.status(401).json({ message: 'Unauthorized' });
-            }
+            const auth = req.auth;
             const { projectId, category } = req.params;
             const { fileName, contentType } = req.query;
             if (!VALID_CATEGORIES.includes(category)) {
@@ -98,150 +89,131 @@ function storageRouter(config) {
                 return res.status(400).json({ message: `Files in the ${category} category must match ${hint}` });
             }
             const project = await Project.findOne({ _id: projectId });
-            if (!project) {
+            if (!project)
                 return res.status(404).json({ message: 'Project not found' });
-            }
-            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized access' });
-            }
             if (!adapter.getPresignedUploadUrl) {
                 return res.status(501).json({ message: 'Storage adapter does not support presigned uploads' });
             }
-            const key = `${projectId}/${category}/${sanitizeFilename(fileName)}`;
-            const url = await adapter.getPresignedUploadUrl(key, contentType);
-            res.json({ url });
+            const ext = fileName.includes('.') ? `.${fileName.split('.').pop().toLowerCase()}` : '';
+            const fileId = crypto_1.default.randomUUID();
+            const storageKey = `${projectId}/${category}/${fileId}${ext}`;
+            const collection = getRawFilesCollection();
+            if (collection) {
+                await collection.insertOne({
+                    _id: new mongodb_1.ObjectId(),
+                    fileId,
+                    projectId,
+                    category,
+                    storageKey,
+                    displayName: fileName,
+                    contentType,
+                    uploadedBy: auth.userId,
+                    createdAt: new Date(),
+                });
+            }
+            const url = await adapter.getPresignedUploadUrl(storageKey, contentType);
+            res.json({ url, fileId, storageKey, displayName: fileName });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to generate upload URL', details: err.message });
         }
     });
-    router.get('/projects/:projectId/storage/lasts', async (req, res) => {
+    router.patch('/projects/:projectId/storage/files/:fileId', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth || !auth.userId || !auth.role) {
-                return res.status(401).json({ message: 'Unauthorized' });
+            const auth = req.auth;
+            const { projectId, fileId } = req.params;
+            const { displayName } = req.body;
+            if (!displayName || typeof displayName !== 'string') {
+                return res.status(400).json({ message: 'displayName is required' });
             }
-            const { projectId } = req.params;
             const project = await Project.findOne({ _id: projectId });
-            if (!project) {
+            if (!project)
                 return res.status(404).json({ message: 'Project not found' });
-            }
-            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized access' });
-            }
-            if (!adapter.listFilesByCategory) {
-                return res.status(501).json({ message: 'Storage adapter does not support listing files by category' });
-            }
-            const results = await Promise.allSettled(VALID_CATEGORIES.map(category => adapter.listFilesByCategory(projectId, category)));
-            const allFiles = results.flatMap(result => result.status === 'fulfilled' ? result.value : []);
-            const latest = allFiles
-                .sort((a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime())
-                .slice(0, 12);
-            res.json({ data: latest });
+            const collection = getRawFilesCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const result = await collection.findOneAndUpdate({ fileId, projectId }, { $set: { displayName } }, { returnDocument: 'after' });
+            if (!result)
+                return res.status(404).json({ message: 'File not found' });
+            res.json({ message: 'File renamed successfully', file: result });
         }
         catch (err) {
-            res.status(500).json({ message: 'Failed to fetch latest files', details: err.message });
+            res.status(500).json({ message: 'Failed to rename file', details: err.message });
         }
     });
-    router.get('/projects/:projectId/storage/:category', async (req, res) => {
+    router.delete('/projects/:projectId/storage/files/:fileId', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth || !auth.userId || !auth.role) {
-                return res.status(401).json({ message: 'Unauthorized' });
-            }
-            const { projectId, category } = req.params;
-            if (!VALID_CATEGORIES.includes(category)) {
-                return res.status(400).json({ message: `Invalid category. Must be one of: ${VALID_CATEGORIES.join(', ')}` });
-            }
+            const auth = req.auth;
+            const { projectId, fileId } = req.params;
             const project = await Project.findOne({ _id: projectId });
-            if (!project) {
+            if (!project)
                 return res.status(404).json({ message: 'Project not found' });
-            }
-            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized access' });
-            }
-            if (!adapter.listFilesByCategory) {
-                return res.status(501).json({ message: 'Storage adapter does not support listing files by category' });
-            }
-            const files = await adapter.listFilesByCategory(projectId, category);
-            res.json({ data: files });
+            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 (adapter.deleteFile)
+                await adapter.deleteFile(fileDoc.storageKey);
+            await collection.deleteOne({ fileId, projectId });
+            res.json({ message: 'File deleted successfully' });
         }
         catch (err) {
-            res.status(500).json({ message: 'Failed to list files', details: err.message });
+            res.status(500).json({ message: 'Failed to delete file', details: err.message });
         }
     });
-    router.patch('/projects/:projectId/storage/:category/:key', async (req, res) => {
+    router.get('/projects/:projectId/storage/lasts', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth || !auth.userId || !auth.role) {
-                return res.status(401).json({ message: 'Unauthorized' });
-            }
-            const { projectId, category } = req.params;
-            const key = decodeURIComponent(req.params.key);
-            const { contentType } = req.body;
-            if (!VALID_CATEGORIES.includes(category)) {
-                return res.status(400).json({ message: `Invalid category. Must be one of: ${VALID_CATEGORIES.join(', ')}` });
-            }
-            if (!contentType) {
-                return res.status(400).json({ message: 'contentType is required' });
-            }
-            if (!validateContentType(contentType, key, category)) {
-                const hint = category === '3d-models'
-                    ? '.glb, .gltf, .obj, .fbx, .stl, or .ply'
-                    : `${category.slice(0, -1)}/* content type`;
-                return res.status(400).json({ message: `Files in the ${category} category must match ${hint}` });
-            }
+            const auth = req.auth;
+            const { projectId } = req.params;
             const project = await Project.findOne({ _id: projectId });
-            if (!project) {
+            if (!project)
                 return res.status(404).json({ message: 'Project not found' });
-            }
-            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized access' });
-            }
-            if (!adapter.getPresignedUploadUrl) {
-                return res.status(501).json({ message: 'Storage adapter does not support presigned uploads' });
-            }
-            const url = await adapter.getPresignedUploadUrl(key, contentType);
-            res.json({ url });
+            const collection = getRawFilesCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const files = await collection.find({ projectId }).sort({ createdAt: -1 }).limit(12).toArray();
+            const data = await Promise.all(files.map(f => resolveFileUrl(f, adapter)));
+            res.json({ data });
         }
         catch (err) {
-            res.status(500).json({ message: 'Failed to generate overwrite URL', details: err.message });
+            res.status(500).json({ message: 'Failed to fetch latest files', details: err.message });
         }
     });
-    router.delete('/projects/:projectId/storage/:category/:key', async (req, res) => {
+    router.get('/projects/:projectId/storage/:category', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth || !auth.userId || !auth.role) {
-                return res.status(401).json({ message: 'Unauthorized' });
-            }
+            const auth = req.auth;
             const { projectId, category } = req.params;
-            const key = decodeURIComponent(req.params.key);
             if (!VALID_CATEGORIES.includes(category)) {
                 return res.status(400).json({ message: `Invalid category. Must be one of: ${VALID_CATEGORIES.join(', ')}` });
             }
             const project = await Project.findOne({ _id: projectId });
-            if (!project) {
+            if (!project)
                 return res.status(404).json({ message: 'Project not found' });
-            }
-            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized access' });
-            }
-            if (!adapter.deleteFile) {
-                return res.status(501).json({ message: 'Storage adapter does not support file deletion' });
-            }
-            await adapter.deleteFile(key);
-            res.json({ message: 'File deleted successfully.' });
+            const collection = getRawFilesCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const files = await collection.find({ projectId, category }).sort({ createdAt: -1 }).toArray();
+            const data = await Promise.all(files.map(f => resolveFileUrl(f, adapter)));
+            res.json({ data });
         }
         catch (err) {
-            res.status(500).json({ message: 'Failed to delete file', details: err.message });
+            res.status(500).json({ message: 'Failed to list files', details: err.message });
         }
     });
-    router.get('/storages', async (req, res) => {
+    router.get('/storages', async (_req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth || !auth.userId || !auth.role) {
-                return res.status(401).json({ message: 'Unauthorized' });
-            }
             const STORAGE_DISPLAY = {
                 s3: { value: 'aws-s3', name: 'AWS S3' },
                 gcs: { value: 'google-cloud-storage', name: 'Google Cloud Storage' },
@@ -260,3 +232,22 @@ function storageRouter(config) {
     });
     return router;
 }
+async function resolveFileUrl(file, adapter) {
+    let url = null;
+    if (adapter.getPresignedGetUrl) {
+        try {
+            url = await adapter.getPresignedGetUrl(file.storageKey);
+        }
+        catch { /* leave null */ }
+    }
+    return {
+        id: file.fileId,
+        displayName: file.displayName,
+        storageKey: file.storageKey,
+        category: file.category,
+        contentType: file.contentType,
+        uploadedBy: file.uploadedBy,
+        createdAt: file.createdAt,
+        url,
+    };
+}

package/dist/models/Model.js

@@ -182,6 +182,7 @@ class Model {
                         projectId: created.id,
                         userId: member.userId,
                         role: member.role,
+                        status: member.status,
                         archived: member.archived || false,
                     }, this.schema);
                 }

package/dist/services/notification.js

@@ -2,9 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNotification = createNotification;
 const manager_1 = require("../models/manager");
+const connectionManager_1 = require("../adapters/database/connectionManager");
 const wsHub_1 = require("./wsHub");
+const MAX_NOTIFICATIONS = 20;
+function getRawNotifCollection() {
+    const model = (0, manager_1.getModel)('notifications', '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('notifications');
+}
 async function createNotification(userId, type, message, data, appId, callback) {
-    const Notification = (0, manager_1.getModel)('notifications');
+    const Notification = (0, manager_1.getModel)('notifications', 'nosql');
     const notification = await Notification.create({
         userId,
         appId: appId ?? null,
@@ -16,6 +26,15 @@ async function createNotification(userId, type, message, data, appId, callback)
         readAt: null,
         createdAt: new Date(),
     });
+    const collection = getRawNotifCollection();
+    if (collection) {
+        const count = await collection.countDocuments({ userId });
+        if (count > MAX_NOTIFICATIONS) {
+            const oldest = await collection.find({ userId }).sort({ createdAt: 1 }).limit(1).toArray();
+            if (oldest.length > 0)
+                await collection.deleteOne({ _id: oldest[0]._id });
+        }
+    }
     (0, wsHub_1.emitToUser)(userId, { type: 'notification', data: notification });
     return notification;
 }

package/package.json

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