streamby-core 0.25.6 → 0.25.8

package/dist/middleware/createRouter.js

@@ -15,6 +15,8 @@ const project_1 = require("./routes/project");
 const export_1 = require("./routes/export");
 const credential_1 = require("./routes/credential");
 const apiConnection_1 = require("./routes/apiConnection");
+const member_1 = require("./routes/member");
+const user_1 = require("./routes/user");
 const auth_2 = require("../services/auth");
 const encryption_1 = require("../utils/encryption");
 function createStreamByRouter(config) {
@@ -42,5 +44,7 @@ function createStreamByRouter(config) {
     router.use((0, export_1.exportRouter)(config));
     router.use((0, credential_1.credentialRouter)(config));
     router.use((0, apiConnection_1.apiConnectionRouter)(config));
+    router.use((0, member_1.memberRouter)(config));
+    router.use((0, user_1.userRouter)(config));
     return router;
 }

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

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

package/dist/middleware/routes/member.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memberRouter = memberRouter;
+const express_1 = require("express");
+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 VALID_ROLES = ['viewer', 'editor', 'admin'];
+function memberRouter(config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    const getSqlConnection = () => {
+        const sqlDb = config.databases?.find(db => db.type === 'sql');
+        if (!sqlDb || !(0, connectionManager_1.getConnectedIds)().includes(sqlDb.id))
+            return null;
+        return (0, connectionManager_1.getConnection)(sqlDb.id).client;
+    };
+    router.get('/projects/:id/members', 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' });
+            }
+            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            }
+            const mainDb = config.databases?.find(db => db.main);
+            if (!mainDb) {
+                return res.status(500).json({ message: 'Main database not configured' });
+            }
+            const User = (0, manager_1.getModel)('users');
+            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 : '',
+                };
+            }));
+            res.json({ members: membersWithUsernames, message: 'Project members fetched successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch project members', details: err.message });
+        }
+    });
+    router.post('/projects/:id/members', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin') {
+                return res.status(403).json({ message: 'Only admins can invite members' });
+            }
+            const projectId = req.params.id;
+            const { userId, role } = req.body;
+            if (!userId || !role) {
+                return res.status(400).json({ message: 'userId and role are required' });
+            }
+            if (!VALID_ROLES.includes(role)) {
+                return res.status(400).json({ message: `role must be one of: ${VALID_ROLES.join(', ')}` });
+            }
+            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 project access' });
+            }
+            const alreadyMember = project.members?.some((m) => m.userId?.toString() === userId?.toString());
+            if (alreadyMember) {
+                return res.status(400).json({ message: 'User is already a member of this project' });
+            }
+            const User = (0, manager_1.getModel)('users');
+            const user = await User.findOne({ _id: userId });
+            if (!user) {
+                return res.status(404).json({ message: 'User not found' });
+            }
+            const newMember = { userId, username: user.username, role, archived: false };
+            if (project.dbType === 'sql') {
+                const connection = getSqlConnection();
+                if (!connection) {
+                    return res.status(503).json({ message: 'SQL connection not available' });
+                }
+                await sql_1.sqlAdapter.create(connection, 'project_members', {
+                    projectId,
+                    userId,
+                    role,
+                    archived: false,
+                }, 'streamby');
+            }
+            else {
+                await Project.update({ _id: projectId }, { $push: { members: newMember } });
+            }
+            res.status(201).json({ member: newMember, message: 'Member invited successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to invite member', details: err.message });
+        }
+    });
+    router.patch('/projects/:id/members/:userId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin') {
+                return res.status(403).json({ message: 'Only admins can update member roles' });
+            }
+            const projectId = req.params.id;
+            const targetUserId = req.params.userId;
+            const { role } = req.body;
+            if (!role || !VALID_ROLES.includes(role)) {
+                return res.status(400).json({ message: `role must be one of: ${VALID_ROLES.join(', ')}` });
+            }
+            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 project access' });
+            }
+            const memberExists = project.members?.some((m) => m.userId?.toString() === targetUserId?.toString());
+            if (!memberExists) {
+                return res.status(404).json({ message: 'Member not found in project' });
+            }
+            if (project.dbType === 'sql') {
+                const connection = getSqlConnection();
+                if (!connection) {
+                    return res.status(503).json({ message: 'SQL connection not available' });
+                }
+                await sql_1.sqlAdapter.update(connection, 'project_members', { projectId, userId: targetUserId }, { role }, 'streamby');
+            }
+            else {
+                const updatedMembers = project.members.map((m) => m.userId?.toString() === targetUserId?.toString() ? { ...m, role } : m);
+                await Project.update({ _id: projectId }, { members: updatedMembers });
+            }
+            res.status(200).json({ message: 'Member role updated successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to update member role', details: err.message });
+        }
+    });
+    router.delete('/projects/:id/members/:userId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin') {
+                return res.status(403).json({ message: 'Only admins can remove members' });
+            }
+            const projectId = req.params.id;
+            const targetUserId = req.params.userId;
+            if (targetUserId === auth.userId) {
+                return res.status(400).json({ message: 'Cannot remove yourself from the project' });
+            }
+            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 project access' });
+            }
+            const memberExists = project.members?.some((m) => m.userId?.toString() === targetUserId?.toString());
+            if (!memberExists) {
+                return res.status(404).json({ message: 'Member not found in project' });
+            }
+            if (project.dbType === 'sql') {
+                const connection = getSqlConnection();
+                if (!connection) {
+                    return res.status(503).json({ message: 'SQL connection not available' });
+                }
+                await sql_1.sqlAdapter.delete(connection, 'project_members', { projectId, userId: targetUserId }, 'streamby');
+            }
+            else {
+                await Project.update({ _id: projectId }, { $pull: { members: { userId: targetUserId } } });
+            }
+            res.status(200).json({ message: 'Member removed successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to remove member', details: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/project.js

@@ -234,38 +234,6 @@ function projectRouter(config) {
             res.status(500).json({ message: 'Failed to unarchive project', details: err.message });
         }
     });
-    router.get('/projects/:id/members', 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' });
-            }
-            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ message: 'Unauthorized project access' });
-            }
-            const mainDb = config.databases?.find(db => db.main);
-            if (!mainDb) {
-                return res.status(500).json({ message: 'Main database not configured' });
-            }
-            const userDbType = mainDb.type;
-            const User = (0, manager_1.getModel)('users', userDbType);
-            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 : ''
-                };
-            }));
-            res.json({ members: membersWithUsernames, message: 'Project members fetched successfully' });
-        }
-        catch (err) {
-            res.status(500).json({ message: 'Failed to fetch project members', details: err.message });
-        }
-    });
     router.post('/projects/:id/image', async (req, res) => {
         try {
             const auth = req.auth;

package/dist/middleware/routes/storage.js

@@ -170,6 +170,44 @@ function storageRouter(config) {
             res.status(500).json({ message: 'Failed to list files', details: err.message });
         }
     });
+    router.patch('/projects/:projectId/storage/:category/:key', 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 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 (!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 });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to generate overwrite URL', details: err.message });
+        }
+    });
     router.delete('/projects/:projectId/storage/:category/:key', async (req, res) => {
         try {
             const auth = await config.authProvider(req);

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

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

package/dist/middleware/routes/user.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userRouter = userRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+function userRouter(config) {
+    const router = (0, express_1.Router)();
+    const User = (0, manager_1.getModel)('users');
+    router.get('/users/search', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const q = (req.query.q || '').trim();
+            if (!q) {
+                return res.status(400).json({ message: 'Query param q is required' });
+            }
+            const allUsers = await User.find({});
+            const lower = q.toLowerCase();
+            const users = allUsers
+                .filter((u) => u.username?.toLowerCase().includes(lower))
+                .slice(0, 20)
+                .map((u) => ({
+                id: u._id || u.id,
+                username: u.username,
+                profilePic: u.profilePic || '',
+            }));
+            res.json({ users });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to search users', details: err.message });
+        }
+    });
+    return router;
+}

package/package.json

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