streamby-core 0.21.6 → 0.21.8

package/README.md

@@ -1,206 +1,206 @@
-# @streamby/core
-
-Middleware framework for building storage-agnostic media APIs.  
-Part of the [StreamBy](https://streamby.nhexa.cl) ecosystem by TerminalCore Labs.
-
----
-
-## 🚀 What is it?
-
-`@streamby/core` is a plug-and-play middleware for Express (or compatible frameworks) that enables file uploads, listings and **multi-project access** over services like:
-
-- ✅ AWS S3
-- ✅ Google Cloud Storage (soon)
-- ✅ Cloudflare R2 (soon)
-- ✅ Local/Personal servers (soon)
-
-It's designed to be installed inside your existing API as a library — **no need to run a separate backend**.
-
----
-
-## 📦 Installation
-
-```bash
-npm install @streamby/core
-```
-
----
-
-## 🧱 Basic usage
-
-```ts
-import express from 'express';
-import { createStreamByRouter } from '@streamby/core';
-
-const app = express();
-
-app.use('/streamby', createStreamByRouter({
-  storageProvider: {
-    type: 's3',
-    config: {
-      bucket: 'your-bucket-name',
-      region: 'your-region',
-      accessKeyId: 'YOUR_AWS_KEY',
-      secretAccessKey: 'YOUR_AWS_SECRET'
-    }
-  },
-  authProvider: async (req) => {
-    // extract token/cookie and validate
-    return {
-      userId: 'demo',
-      projects: ['demo-project'],
-      role: 'admin',
-    };
-  },
-  projectProvider: async (projectId) => {
-    // fetch project from your DB
-    return {
-      id: projectId,
-      name: 'Demo Project',
-      description: 'Demo for StreamBy integration',
-      rootFolders: [],
-      settings: { allowUpload: true }
-    };
-  }
-}));
-
-app.listen(3000);
-```
-
----
-
-## 🧪 Testing
-
-```bash
-npm run test
-```
-
-Unit tests use [Vitest](https://vitest.dev) and [Supertest](https://www.npmjs.com/package/supertest).
-
----
-
-## 📁 Features
-
-- 📂 Multi-project access control
-- 🔐 Project-aware file uploads & listings
-- 🧹 Modular adapters per storage provider
-- 🧰 Built-in testability with mock auth & storage
-- ✨ Simple to extend for custom business logic
-
----
-
-## 🗺️ API Endpoints
-
-Here's a summary of the key API endpoints provided by `@streamby/core`:
-
-### `GET /streamby/projects`
-
-Lists all projects accessible by the authenticated user.
-
-**Query Parameters:**
-- `archived`: (Optional) Filter projects by their archived status.
-  - `true`: Returns only archived projects.
-  - `false`: Returns only unarchived projects.
-  - (Omitted): Returns all projects (both archived and unarchived).
-
-**Example Response:**
-```json
-{
-  "projects": [
-    {
-      "id": "project1_id",
-      "dbType": "nosql",
-      "name": "My NoSQL Project",
-      "image": "url_to_image",
-      "archived": false
-    },
-    {
-      "id": "project2_id",
-      "dbType": "sql",
-      "name": "My SQL Project",
-      "image": "url_to_image",
-      "archived": true
-    }
-  ]
-}
-```
-
-### `PATCH /streamby/projects/:id/archive`
-
-Archives a specific project. After archiving, it returns the complete list of projects for the user, including the updated project.
-
-**Example Response:**
-```json
-{
-  "success": true,
-  "projects": [
-    {
-      "id": "project1_id",
-      "dbType": "nosql",
-      "name": "My NoSQL Project",
-      "image": "url_to_image",
-      "archived": true
-    },
-    {
-      "id": "project2_id",
-      "dbType": "sql",
-      "name": "My SQL Project",
-      "image": "url_to_image",
-      "archived": false
-    }
-  ]
-}
-```
-
-### `PATCH /streamby/projects/:id/unarchive`
-
-Unarchives a specific project. After unarchiving, it returns the complete list of projects for the user, including the updated project.
-
-**Example Response:**
-```json
-{
-  "success": true,
-  "projects": [
-    {
-      "id": "project1_id",
-      "dbType": "nosql",
-      "name": "My NoSQL Project",
-      "image": "url_to_image",
-      "archived": false
-    },
-    {
-      "id": "project2_id",
-      "dbType": "sql",
-      "name": "My SQL Project",
-      "image": "url_to_image",
-      "archived": false
-    }
-  ]
-}
-```
-
----
-
-## 🚣 Roadmap
-
-- [ ] Support for Google Cloud Storage
-- [ ] CLI tool for uploading files
-- [ ] Role-based access control middleware
-- [ ] Plugin system for extended routes
-- [ ] Streaming support (HLS, audio, etc.)
-
----
-
-## 🧑‍💻 Maintained by
-
-**TerminalCore Labs** – part of [Nhexa Entertainment](https://nhexa.cl)  
-Developed as open-source infrastructure for creative and media-oriented apps.
-
-Visit us [here](https://terminalcore.cl)
-
----
-
-## 📟 License
-
-[MIT](./LICENSE)
-
+# @streamby/core
+
+Middleware framework for building storage-agnostic media APIs.  
+Part of the [StreamBy](https://streamby.nhexa.cl) ecosystem by TerminalCore Labs.
+
+---
+
+## 🚀 What is it?
+
+`@streamby/core` is a plug-and-play middleware for Express (or compatible frameworks) that enables file uploads, listings and **multi-project access** over services like:
+
+- ✅ AWS S3
+- ✅ Google Cloud Storage (soon)
+- ✅ Cloudflare R2 (soon)
+- ✅ Local/Personal servers (soon)
+
+It's designed to be installed inside your existing API as a library — **no need to run a separate backend**.
+
+---
+
+## 📦 Installation
+
+```bash
+npm install @streamby/core
+```
+
+---
+
+## 🧱 Basic usage
+
+```ts
+import express from 'express';
+import { createStreamByRouter } from '@streamby/core';
+
+const app = express();
+
+app.use('/streamby', createStreamByRouter({
+  storageProvider: {
+    type: 's3',
+    config: {
+      bucket: 'your-bucket-name',
+      region: 'your-region',
+      accessKeyId: 'YOUR_AWS_KEY',
+      secretAccessKey: 'YOUR_AWS_SECRET'
+    }
+  },
+  authProvider: async (req) => {
+    // extract token/cookie and validate
+    return {
+      userId: 'demo',
+      projects: ['demo-project'],
+      role: 'admin',
+    };
+  },
+  projectProvider: async (projectId) => {
+    // fetch project from your DB
+    return {
+      id: projectId,
+      name: 'Demo Project',
+      description: 'Demo for StreamBy integration',
+      rootFolders: [],
+      settings: { allowUpload: true }
+    };
+  }
+}));
+
+app.listen(3000);
+```
+
+---
+
+## 🧪 Testing
+
+```bash
+npm run test
+```
+
+Unit tests use [Vitest](https://vitest.dev) and [Supertest](https://www.npmjs.com/package/supertest).
+
+---
+
+## 📁 Features
+
+- 📂 Multi-project access control
+- 🔐 Project-aware file uploads & listings
+- 🧹 Modular adapters per storage provider
+- 🧰 Built-in testability with mock auth & storage
+- ✨ Simple to extend for custom business logic
+
+---
+
+## 🗺️ API Endpoints
+
+Here's a summary of the key API endpoints provided by `@streamby/core`:
+
+### `GET /streamby/projects`
+
+Lists all projects accessible by the authenticated user.
+
+**Query Parameters:**
+- `archived`: (Optional) Filter projects by their archived status.
+  - `true`: Returns only archived projects.
+  - `false`: Returns only unarchived projects.
+  - (Omitted): Returns all projects (both archived and unarchived).
+
+**Example Response:**
+```json
+{
+  "projects": [
+    {
+      "id": "project1_id",
+      "dbType": "nosql",
+      "name": "My NoSQL Project",
+      "image": "url_to_image",
+      "archived": false
+    },
+    {
+      "id": "project2_id",
+      "dbType": "sql",
+      "name": "My SQL Project",
+      "image": "url_to_image",
+      "archived": true
+    }
+  ]
+}
+```
+
+### `PATCH /streamby/projects/:id/archive`
+
+Archives a specific project. After archiving, it returns the complete list of projects for the user, including the updated project.
+
+**Example Response:**
+```json
+{
+  "success": true,
+  "projects": [
+    {
+      "id": "project1_id",
+      "dbType": "nosql",
+      "name": "My NoSQL Project",
+      "image": "url_to_image",
+      "archived": true
+    },
+    {
+      "id": "project2_id",
+      "dbType": "sql",
+      "name": "My SQL Project",
+      "image": "url_to_image",
+      "archived": false
+    }
+  ]
+}
+```
+
+### `PATCH /streamby/projects/:id/unarchive`
+
+Unarchives a specific project. After unarchiving, it returns the complete list of projects for the user, including the updated project.
+
+**Example Response:**
+```json
+{
+  "success": true,
+  "projects": [
+    {
+      "id": "project1_id",
+      "dbType": "nosql",
+      "name": "My NoSQL Project",
+      "image": "url_to_image",
+      "archived": false
+    },
+    {
+      "id": "project2_id",
+      "dbType": "sql",
+      "name": "My SQL Project",
+      "image": "url_to_image",
+      "archived": false
+    }
+  ]
+}
+```
+
+---
+
+## 🚣 Roadmap
+
+- [ ] Support for Google Cloud Storage
+- [ ] CLI tool for uploading files
+- [ ] Role-based access control middleware
+- [ ] Plugin system for extended routes
+- [ ] Streaming support (HLS, audio, etc.)
+
+---
+
+## 🧑‍💻 Maintained by
+
+**TerminalCore Labs** – part of [Nhexa Entertainment](https://nhexa.cl)  
+Developed as open-source infrastructure for creative and media-oriented apps.
+
+Visit us [here](https://terminalcore.cl)
+
+---
+
+## 📟 License
+
+[MIT](./LICENSE)
+

package/dist/middleware/routes/auth.js

@@ -12,10 +12,10 @@ function authRouter(config) {
                 !auth.role) {
                 throw new Error('Invalid or missing authentication context');
             }
-            return res.status(200).json({ logged: true, ...auth });
+            return res.status(200).json({ logged: true, message: 'Authentication successful', ...auth });
         }
         catch (err) {
-            return res.status(401).json({ logged: false });
+            return res.status(401).json({ logged: false, message: err.message });
         }
     });
     return router;

package/dist/middleware/routes/database.js

@@ -11,16 +11,16 @@ function databaseRouter(config) {
             if (!auth ||
                 !auth.userId ||
                 !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
+                return res.status(401).json({ message: 'Unauthorized' });
             }
             const connectedDbIds = (0, connectionManager_1.getConnectedIds)();
             const databases = (config.databases || [])
                 .filter(db => connectedDbIds.includes(db.id))
                 .map(db => ({ name: db.id, value: db.type }));
-            res.status(200).json({ databases });
+            res.status(200).json({ databases, message: 'Databases retrieved successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to get databases' });
+            res.status(500).json({ message: err.message });
         }
     });
     return router;

package/dist/middleware/routes/export.js

@@ -14,22 +14,22 @@ function exportRouter(config) {
             if (!auth ||
                 !auth.userId ||
                 !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
+                return res.status(401).json({ message: 'Unauthorized' });
             }
             const projectId = req.params.id;
             const exportId = req.params.export_id;
             const project = await Project.findOne({ _id: projectId });
             if (!project) {
-                return res.status(404).json({ error: 'Project not found' });
+                return res.status(404).json({ message: 'Project not found' });
             }
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ error: 'Unauthorized access' });
+                return res.status(403).json({ message: 'Unauthorized access' });
             }
             const data = await Export.findOne({ _id: exportId });
-            res.json({ data: { ...data, id: data._id || data.id, _id: undefined } });
+            res.json({ data: { ...data, id: data._id || data.id, _id: undefined }, message: 'Export data fetched successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to fetch export data', details: err.message });
+            res.status(500).json({ message: 'Failed to fetch export data', details: err.message });
         }
     });
     router.post('/projects/:id/exports', async (req, res) => {
@@ -38,16 +38,16 @@ function exportRouter(config) {
             if (!auth ||
                 !auth.userId ||
                 !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
+                return res.status(401).json({ message: 'Unauthorized' });
             }
             const projectId = req.params.id;
             const { name, description, collectionName } = req.body;
             if (!name || !collectionName) {
-                return res.status(400).json({ error: 'Missing export name or collectionName' });
+                return res.status(400).json({ message: 'Missing export name or collectionName' });
             }
             const project = await Project.findOne({ _id: projectId });
             if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ error: 'Unauthorized project access' });
+                return res.status(403).json({ message: 'Unauthorized project access' });
             }
             const newExport = await Export.create({
                 name,
@@ -55,10 +55,10 @@ function exportRouter(config) {
                 collectionName,
                 projectId
             });
-            res.status(201).json({ data: { ...newExport, id: newExport._id || newExport.id, _id: undefined } });
+            res.status(201).json({ data: { ...newExport, id: newExport._id || newExport.id, _id: undefined }, message: 'Export created successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to create export', details: err.message });
+            res.status(500).json({ message: 'Failed to create export', details: err.message });
         }
     });
     return router;

package/dist/middleware/routes/file.js

@@ -16,20 +16,20 @@ function fileRouter(config) {
             if (!auth ||
                 !auth.userId ||
                 !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
+                return res.status(401).json({ message: 'Unauthorized' });
             }
             if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ error: 'Permission denied' });
+                return res.status(403).json({ message: 'Permission denied' });
             }
             const projectId = req.params.id;
             if (!projectId) {
-                return res.status(400).json({ error: 'Missing projectId' });
+                return res.status(400).json({ message: 'Missing projectId' });
             }
             const response = await (0, presign_1.getPresignedProjectImageUrl)(adapter, projectId);
-            res.status(200).json(response);
+            res.status(200).json({ ...response, message: 'Presigned URL generated successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to generate presigned URL', details: err.message });
+            res.status(500).json({ message: 'Failed to generate presigned URL', details: err.message });
         }
     });
     router.delete('/delete-project-image-url/:id', async (req, res) => {
@@ -38,21 +38,21 @@ function fileRouter(config) {
             if (!auth ||
                 !auth.userId ||
                 !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
+                return res.status(401).json({ message: 'Unauthorized' });
             }
             if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ error: 'Permission denied' });
+                return res.status(403).json({ message: 'Permission denied' });
             }
             const projectId = req.params.id;
             if (!projectId) {
-                return res.status(400).json({ error: 'Missing 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);
+            res.status(201).json({ ...updated, message: 'Image deleted successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to delete image', details: err.message });
+            res.status(500).json({ message: 'Failed to delete image', details: err.message });
         }
     });
     router.get('/files', async (req, res) => {
@@ -61,17 +61,17 @@ function fileRouter(config) {
             if (!auth ||
                 !auth.userId ||
                 !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
+                return res.status(401).json({ message: 'Unauthorized' });
             }
             const projectId = (req.query.projectId || req.headers['x-project-id']);
             if (!projectId) {
-                return res.status(403).json({ error: 'Unauthorized or missing projectId' });
+                return res.status(403).json({ message: 'Unauthorized or missing projectId' });
             }
             const files = await (0, file_1.listFilesService)(adapter, req, projectId);
-            res.json(files);
+            res.json({ files, message: 'Files listed successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to list files', details: err });
+            res.status(500).json({ message: 'Failed to list files', details: err });
         }
     });
     return router;

package/dist/middleware/routes/project.js

@@ -6,8 +6,10 @@ 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);
@@ -21,12 +23,7 @@ function projectRouter(config) {
     };
     router.get('/projects', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth ||
-                !auth.userId ||
-                !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
-            }
+            const auth = req.auth;
             const archivedQuery = req.query.archived;
             const filterArchived = archivedQuery !== undefined ? String(archivedQuery).toLowerCase() === 'true' : undefined;
             const allProjects = await Project.find({}); // Fetch all projects
@@ -42,34 +39,29 @@ function projectRouter(config) {
                 return true;
             })
                 .map(project => mapProjectToResponseFormat(project, auth.userId));
-            res.json({ projects });
+            res.json({ projects, message: 'Projects listed successfully' });
         }
         catch (err) {
             console.error('Error in /projects endpoint:', err);
-            res.status(500).json({ error: 'Failed to list projects', details: err });
+            res.status(500).json({ message: 'Failed to list projects', details: err });
         }
     });
     router.post('/projects/create', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth ||
-                !auth.userId ||
-                !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
-            }
+            const auth = req.auth;
             if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ error: 'Permission denied' });
+                return res.status(403).json({ message: 'Permission denied' });
             }
             const { name, description, dbType, image } = req.body;
             const mainDb = config.databases?.find(db => db.main);
             if (!mainDb) {
-                return res.status(500).json({ error: 'Main database not configured' });
+                return res.status(500).json({ message: 'Main database not configured' });
             }
             const userDbType = mainDb.type;
             const User = (0, manager_1.getModel)('users', userDbType);
             const user = await User.findOne({ _id: auth.userId });
             if (!user) {
-                return res.status(404).json({ error: 'User not found' });
+                return res.status(404).json({ message: 'User not found' });
             }
             const newProject = await Project.create({
                 dbType: dbType || 'nosql',
@@ -78,102 +70,103 @@ function projectRouter(config) {
                 image: image || '',
                 members: [{ userId: auth.userId, username: user.username, role: "admin", archived: false }]
             });
-            res.status(201).json({ project: { ...newProject, id: newProject._id || newProject.id, _id: undefined } });
+            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
+            })
+                .map(project => mapProjectToResponseFormat(project, auth.userId));
+            res.status(200).json({ success: true, projects: projects, projectId: newProject._id || newProject.id, message: 'Project created successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to create project', details: err.message });
+            res.status(500).json({ message: 'Failed to create project', details: err.message });
         }
     });
     router.get('/projects/:id', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth ||
-                !auth.userId ||
-                !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
-            }
+            const auth = req.auth;
             const projectId = req.params.id;
             const project = await Project.findOne({ _id: projectId });
             if (!project) {
-                return res.status(404).json({ error: 'Project not found' });
+                return res.status(404).json({ message: 'Project not found' });
             }
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ error: 'Unauthorized project access' });
+                return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            res.json({ project: { ...project, id: project._id || project.id, _id: undefined } });
+            res.json({ project: { ...project, id: project._id || project.id, _id: undefined }, message: 'Project fetched successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to fetch project', details: err.message });
+            res.status(500).json({ message: 'Failed to fetch project', details: err.message });
         }
     });
     router.patch('/projects/:id', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth ||
-                !auth.userId ||
-                !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
-            }
+            const auth = req.auth;
             if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ error: 'Permission denied' });
+                return res.status(403).json({ message: 'Permission denied' });
             }
             const projectId = req.params.id;
             const updates = req.body;
             const project = await Project.findOne({ _id: projectId });
             if (!project) {
-                return res.status(404).json({ error: 'Project not found' });
+                return res.status(404).json({ message: 'Project not found' });
             }
             if (!updates || typeof updates !== 'object') {
-                return res.status(400).json({ error: 'Missing updates payload' });
+                return res.status(400).json({ message: 'Missing updates payload' });
             }
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ error: 'Unauthorized project access' });
+                return res.status(403).json({ message: 'Unauthorized project access' });
             }
             const updated = await Project.update({ _id: projectId }, updates);
             if (!updated) {
-                return res.status(404).json({ error: 'Project not found or not updated' });
+                return res.status(404).json({ message: 'Project not found or not updated' });
             }
-            res.status(200).json({ success: true, project: { ...updated, id: updated._id || updated.id, _id: undefined } });
+            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
+            })
+                .map(project => mapProjectToResponseFormat(project, auth.userId));
+            res.status(200).json({ success: true, projects: projects, projectId: updated._id || updated.id, message: 'Project updated successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to update project', details: err.message });
+            res.status(500).json({ message: 'Failed to update project', details: err.message });
         }
     });
     router.delete('/projects/:id', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth ||
-                !auth.userId ||
-                !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
-            }
+            const auth = req.auth;
             const projectId = req.params.id;
             const project = await Project.findOne({ _id: projectId });
             if (!project) {
-                return res.status(404).json({ error: 'Project not found' });
+                return res.status(404).json({ message: 'Project not found' });
             }
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ error: 'Unauthorized project access' });
+                return res.status(403).json({ message: 'Unauthorized project access' });
             }
             await Project.delete({ _id: projectId });
-            res.status(200).json({ success: true });
+            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
+            })
+                .map(project => mapProjectToResponseFormat(project, auth.userId));
+            res.status(200).json({ success: true, projects: projects, message: 'Project deleted successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to delete project', details: err.message });
+            res.status(500).json({ message: 'Failed to delete project', details: err.message });
         }
     });
     router.patch('/projects/:id/archive', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth ||
-                !auth.userId ||
-                !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
-            }
+            const auth = req.auth;
             const projectId = req.params.id;
             const project = await Project.findOne({ _id: projectId });
             if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ error: 'Unauthorized project access' });
+                return res.status(403).json({ message: 'Unauthorized project access' });
             }
             if (project.dbType === 'sql') {
                 const connection = (0, connectionManager_1.getConnection)(config.databases?.find(db => db.main)?.id || '').client;
@@ -182,7 +175,7 @@ function projectRouter(config) {
             else {
                 const memberIndex = project.members.findIndex((member) => member.userId === auth.userId);
                 if (memberIndex === -1) {
-                    return res.status(403).json({ error: 'Unauthorized project access' });
+                    return res.status(403).json({ message: 'Unauthorized project access' });
                 }
                 project.members[memberIndex].archived = true;
                 project.members[memberIndex].archivedBy = auth.userId;
@@ -197,24 +190,19 @@ function projectRouter(config) {
                 return isMember; // Only include projects where the user is a member
             })
                 .map(project => mapProjectToResponseFormat(project, auth.userId));
-            res.status(200).json({ success: true, projects: projects });
+            res.status(200).json({ success: true, projects: projects, message: 'Project archived successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to archive project', details: err.message });
+            res.status(500).json({ message: 'Failed to archive project', details: err.message });
         }
     });
     router.patch('/projects/:id/unarchive', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth ||
-                !auth.userId ||
-                !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
-            }
+            const auth = req.auth;
             const projectId = req.params.id;
             const project = await Project.findOne({ _id: projectId });
             if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ error: 'Unauthorized project access' });
+                return res.status(403).json({ message: 'Unauthorized project access' });
             }
             if (project.dbType === 'sql') {
                 const connection = (0, connectionManager_1.getConnection)(config.databases?.find(db => db.main)?.id || '').client;
@@ -223,7 +211,7 @@ function projectRouter(config) {
             else {
                 const memberIndex = project.members.findIndex((member) => member.userId === auth.userId);
                 if (memberIndex === -1) {
-                    return res.status(403).json({ error: 'Unauthorized project access' });
+                    return res.status(403).json({ message: 'Unauthorized project access' });
                 }
                 project.members[memberIndex].archived = false;
                 project.members[memberIndex].archivedBy = null;
@@ -238,31 +226,26 @@ function projectRouter(config) {
                 return isMember; // Only include projects where the user is a member
             })
                 .map(project => mapProjectToResponseFormat(project, auth.userId));
-            res.status(200).json({ success: true, projects: projects });
+            res.status(200).json({ success: true, projects: projects, message: 'Project unarchived successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to unarchive project', details: err.message });
+            res.status(500).json({ message: 'Failed to unarchive project', details: err.message });
         }
     });
     router.get('/projects/:id/members', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth ||
-                !auth.userId ||
-                !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
-            }
+            const auth = req.auth;
             const projectId = req.params.id;
             const project = await Project.findOne({ _id: projectId });
             if (!project) {
-                return res.status(404).json({ error: 'Project not found' });
+                return res.status(404).json({ message: 'Project not found' });
             }
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ error: 'Unauthorized project access' });
+                return res.status(403).json({ message: 'Unauthorized project access' });
             }
             const mainDb = config.databases?.find(db => db.main);
             if (!mainDb) {
-                return res.status(500).json({ error: 'Main database not configured' });
+                return res.status(500).json({ message: 'Main database not configured' });
             }
             const userDbType = mainDb.type;
             const User = (0, manager_1.getModel)('users', userDbType);
@@ -275,43 +258,38 @@ function projectRouter(config) {
                     profilePic: user ? user.profilePic : ''
                 };
             }));
-            res.json({ members: membersWithUsernames });
+            res.json({ members: membersWithUsernames, message: 'Project members fetched successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to fetch project members', details: err.message });
+            res.status(500).json({ message: 'Failed to fetch project members', details: err.message });
         }
     });
     router.post('/projects/:id/image', async (req, res) => {
         try {
-            const auth = await config.authProvider(req);
-            if (!auth ||
-                !auth.userId ||
-                !auth.role) {
-                return res.status(401).json({ error: 'Unauthorized' });
-            }
+            const auth = req.auth;
             if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ error: 'Permission denied' });
+                return res.status(403).json({ message: 'Permission denied' });
             }
             const projectId = req.params.id;
             const { imageUrl } = req.body;
             if (!projectId || !imageUrl) {
-                return res.status(400).json({ error: 'Missing projectId or imageUrl' });
+                return res.status(400).json({ message: 'Missing projectId or imageUrl' });
             }
             const project = await Project.findOne({ _id: projectId });
             if (!project) {
-                return res.status(404).json({ error: 'Project not found' });
+                return res.status(404).json({ message: 'Project not found' });
             }
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ error: 'Unauthorized project access' });
+                return res.status(403).json({ message: 'Unauthorized project access' });
             }
             const updatedProject = await Project.update({ _id: projectId }, { image: imageUrl });
             if (!updatedProject) {
-                return res.status(404).json({ error: 'Project not found or not updated' });
+                return res.status(404).json({ message: 'Project not found or not updated' });
             }
-            res.status(200).json({ success: true, project: { ...updatedProject, id: updatedProject._id || updatedProject.id, _id: undefined } });
+            res.status(200).json({ success: true, project: { ...updatedProject, id: updatedProject._id || updatedProject.id, _id: undefined }, message: 'Project image updated successfully' });
         }
         catch (err) {
-            res.status(500).json({ error: 'Failed to update project image', details: err.message });
+            res.status(500).json({ message: 'Failed to update project image', details: err.message });
         }
     });
     return router;

package/dist/services/auth.d.ts

@@ -1,2 +1,5 @@
-import { AuthContext } from '../types';
-export declare function checkRole(auth: AuthContext, required: 'viewer' | 'editor' | 'admin'): void;
+import { Auth } from '../types';
+import { Request, Response, NextFunction } from 'express';
+import { StreamByConfig } from '../types';
+export declare const authenticate: (config: StreamByConfig) => (req: Request, res: Response, next: NextFunction) => Promise<Response<any, Record<string, any>> | undefined>;
+export declare function checkRole(auth: Auth, required: 'viewer' | 'editor' | 'admin'): void;

package/dist/services/auth.js

@@ -1,6 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.authenticate = void 0;
 exports.checkRole = checkRole;
+const authenticate = (config) => async (req, res, next) => {
+    try {
+        const auth = await config.authProvider(req);
+        if (!auth || !auth.userId || !auth.role) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+        req.auth = auth;
+        next();
+    }
+    catch (error) {
+        console.error('Authentication failed:', error);
+        return res.status(401).json({ error: 'Unauthorized' });
+    }
+};
+exports.authenticate = authenticate;
 function checkRole(auth, required) {
     const roles = ['viewer', 'editor', 'admin'];
     const userIdx = roles.indexOf(auth.role);

package/dist/types/index.d.ts

@@ -61,12 +61,12 @@ export interface StreamByConfig {
     databases?: DatabaseCredential[];
     adapter?: StorageAdapter;
 }
-export interface AuthContext {
+export interface Auth {
     userId: string;
     username: string;
     role: 'viewer' | 'editor' | 'admin';
 }
-export type AuthProvider = (req: Request) => Promise<AuthContext>;
+export type AuthProvider = (req: Request) => Promise<Auth>;
 export interface Export {
     _id?: string;
     id: string;

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "streamby-core",
-  "version": "0.21.6",
-  "description": "StreamBy middleware framework for media storage management",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest",
-    "dev": "ts-node-dev --respawn --clear dev.ts",
-    "prepublishOnly": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/GwerhDev/StreamBy-Package.git"
-  },
-  "keywords": [
-    "streamby",
-    "middleware",
-    "upload",
-    "storage",
-    "s3",
-    "express",
-    "typescript"
-  ],
-  "author": "TerminalCore Labs",
-  "license": "MIT",
-  "dependencies": {
-    "@aws-sdk/client-s3": "^3.528.0",
-    "@aws-sdk/s3-request-presigner": "^3.787.0",
-    "@prisma/client": "^6.12.0",
-    "bcrypt": "^5.1.1",
-    "dotenv": "^16.5.0",
-    "express": "^4.0.0",
-    "mongodb": "^6.17.0",
-    "mongoose": "^8.13.2",
-    "pg": "^8.16.3",
-    "prisma": "^6.12.0"
-  },
-  "devDependencies": {
-    "@types/bcrypt": "^5.0.2",
-    "@types/cors": "^2.8.18",
-    "@types/express": "^4.17.17",
-    "@types/mongodb": "^4.0.7",
-    "@types/node": "^22.15.21",
-    "@types/pg": "^8.15.4",
-    "@types/supertest": "^6.0.3",
-    "cors": "^2.8.5",
-    "supertest": "^7.1.4",
-    "ts-node-dev": "^2.0.0",
-    "typescript": "^5.8.3",
-    "vitest": "^3.1.1"
-  },
-  "peerDependencies": {
-    "express": "^4.0.0"
-  }
-}
+{
+  "name": "streamby-core",
+  "version": "0.21.8",
+  "description": "StreamBy middleware framework for media storage management",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest",
+    "dev": "ts-node-dev --respawn --clear dev.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GwerhDev/StreamBy-Package.git"
+  },
+  "keywords": [
+    "streamby",
+    "middleware",
+    "upload",
+    "storage",
+    "s3",
+    "express",
+    "typescript"
+  ],
+  "author": "TerminalCore Labs",
+  "license": "MIT",
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.528.0",
+    "@aws-sdk/s3-request-presigner": "^3.787.0",
+    "@prisma/client": "^6.12.0",
+    "bcrypt": "^5.1.1",
+    "dotenv": "^16.5.0",
+    "express": "^4.0.0",
+    "mongodb": "^6.17.0",
+    "mongoose": "^8.13.2",
+    "pg": "^8.16.3",
+    "prisma": "^6.12.0"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^5.0.2",
+    "@types/cors": "^2.8.18",
+    "@types/express": "^4.17.17",
+    "@types/mongodb": "^4.0.7",
+    "@types/node": "^22.15.21",
+    "@types/pg": "^8.15.4",
+    "@types/supertest": "^6.0.3",
+    "cors": "^2.8.5",
+    "supertest": "^7.1.4",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
+  },
+  "peerDependencies": {
+    "express": "^4.0.0"
+  }
+}