streamby-core 0.21.2 → 0.21.4

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/adapters/database/connectionManager.js

@@ -49,6 +49,7 @@ const ensureTablesExist = async (pool) => {
         id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
         name VARCHAR(255) NOT NULL,
         description TEXT,
+        image TEXT,
         "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
         "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
       );

package/dist/adapters/storage/s3.js

@@ -54,12 +54,15 @@ class S3Adapter {
         return await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn: 3600 });
     }
     async getPresignedProjectImageUrl(projectId) {
+        const key = `${projectId}/project-image`;
         const command = new client_s3_1.PutObjectCommand({
             Bucket: this.bucket,
-            Key: `${projectId}/project-image`,
+            Key: key,
             ContentType: 'image/jpeg',
         });
-        return await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn: 3600 });
+        const url = await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn: 3600 });
+        const publicUrl = `https://${this.bucket}.s3.amazonaws.com/${key}`;
+        return { url, publicUrl };
     }
 }
 exports.S3Adapter = S3Adapter;

package/dist/middleware/createRouter.js

@@ -21,6 +21,10 @@ function createStreamByRouter(config) {
         const allDbIds = config.databases.map(db => db.id);
         (0, manager_1.registerModel)('projects', allDbIds, 'projects');
         (0, manager_1.registerModel)('exports', allDbIds, 'exports');
+        const mainDb = config.databases.find(db => db.main);
+        if (mainDb) {
+            (0, manager_1.registerModel)('users', [mainDb.id], 'users');
+        }
     }
     router.use((0, auth_1.authRouter)(config));
     router.use((0, database_1.databaseRouter)(config));

package/dist/middleware/routes/file.js

@@ -25,8 +25,8 @@ function fileRouter(config) {
             if (!projectId) {
                 return res.status(400).json({ error: 'Missing projectId' });
             }
-            const url = await (0, presign_1.getPresignedProjectImageUrl)(adapter, projectId);
-            res.json(url);
+            const response = await (0, presign_1.getPresignedProjectImageUrl)(adapter, projectId);
+            res.status(200).json(response);
         }
         catch (err) {
             res.status(500).json({ error: 'Failed to generate presigned URL', details: err.message });

package/dist/middleware/routes/project.js

@@ -58,12 +58,23 @@ function projectRouter(config) {
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ error: 'Permission denied' });
             }
-            const { name, description, dbType } = req.body;
+            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' });
+            }
+            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' });
+            }
             const newProject = await Project.create({
                 dbType: dbType || 'nosql',
                 name,
                 description: description || '',
-                members: [{ userId: auth.userId, role: "admin", archived: false }]
+                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 } });
         }
@@ -221,11 +232,59 @@ function projectRouter(config) {
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ error: 'Unauthorized project access' });
             }
-            res.json({ members: project.members });
+            const mainDb = config.databases?.find(db => db.main);
+            if (!mainDb) {
+                return res.status(500).json({ error: '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 });
         }
         catch (err) {
             res.status(500).json({ error: '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' });
+            }
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ error: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const { imageUrl } = req.body;
+            if (!projectId || !imageUrl) {
+                return res.status(400).json({ error: 'Missing projectId or imageUrl' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
+                return res.status(403).json({ error: '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' });
+            }
+            res.status(200).json({ success: true, project: { ...updatedProject, id: updatedProject._id || updatedProject.id, _id: undefined } });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to update project image', details: err.message });
+        }
+    });
     return router;
 }

package/dist/models/Model.d.ts

@@ -3,6 +3,7 @@ export declare class Model<T extends Document> {
     private connectionIds;
     private tableName;
     constructor(connectionIds: string[], tableName: string);
+    useDbType(dbType: string): Model<T>;
     find(filter: any): Promise<T[]>;
     private transformResult;
     findOne(filter: any): Promise<T | null>;

package/dist/models/Model.js

@@ -10,6 +10,13 @@ class Model {
         this.connectionIds = connectionIds;
         this.tableName = tableName;
     }
+    useDbType(dbType) {
+        const filteredConnectionIds = this.connectionIds.filter(id => {
+            const connection = (0, connectionManager_1.getConnection)(id);
+            return connection.type === dbType;
+        });
+        return new Model(filteredConnectionIds, this.tableName);
+    }
     async find(filter) {
         const allResults = [];
         const activeConnectionIds = this.connectionIds.filter(id => (0, connectionManager_1.getConnectedIds)().includes(id));
@@ -156,6 +163,7 @@ class Model {
                     await sql_1.sqlAdapter.create(connection, 'project_members', {
                         projectId: created.id,
                         userId: member.userId,
+                        role: member.role,
                         archived: member.archived || false,
                     });
                 }
@@ -169,71 +177,89 @@ class Model {
         return data;
     }
     async update(filter, data) {
-        const activeConnectionIds = this.connectionIds.filter(id => (0, connectionManager_1.getConnectedIds)().includes(id));
-        for (const connectionId of activeConnectionIds) {
-            const clientEntry = (0, connectionManager_1.getConnection)(connectionId);
-            const connection = clientEntry.client;
-            const dbType = clientEntry.type;
-            let processedFilter = { ...filter };
-            // Handle specific member archiving/unarchiving
-            if (data["members.$.archived"] !== undefined && processedFilter["_id"] && processedFilter["members.userId"]) {
-                const projectId = processedFilter["_id"];
-                const userIdToUpdate = processedFilter["members.userId"];
-                const newArchivedStatus = data["members.$.archived"];
-                const archivedBy = data["members.$.archivedBy"];
-                const archivedAt = data["members.$.archivedAt"];
-                if (dbType === 'sql') {
-                    // For SQL, directly update the project_members table
-                    const memberUpdateResult = await sql_1.sqlAdapter.update(connection, 'project_members', { projectId: projectId, userId: userIdToUpdate }, { archived: newArchivedStatus, archivedBy: archivedBy, archivedAt: archivedAt });
-                    // After updating the member, fetch the full project to return
-                    if (memberUpdateResult) {
-                        const updatedProject = await this.findOne({ _id: projectId });
-                        return updatedProject;
-                    }
+        const existingProject = await this.findOne(filter); // Find the project first
+        if (!existingProject) {
+            return null; // Project not found
+        }
+        const targetDbType = existingProject.dbType; // Get the actual dbType of the project
+        // Find the connection that matches the targetDbType
+        const clientEntry = this.connectionIds
+            .map(id => (0, connectionManager_1.getConnection)(id))
+            .find(entry => entry.type === targetDbType);
+        if (!clientEntry) {
+            throw new Error(`No active connection found for database type: ${targetDbType}`);
+        }
+        const connection = clientEntry.client;
+        const dbType = clientEntry.type; // This will be the targetDbType
+        let updateFilter = {}; // Initialize updateFilter here
+        // Construct the updateFilter based on the actual dbType of the project
+        if (dbType === 'sql') {
+            updateFilter.id = existingProject.id; // Use the 'id' from the existingProject
+        }
+        else if (dbType === 'nosql') {
+            // Ensure _id is an ObjectId for NoSQL updates
+            if (existingProject._id && typeof existingProject._id === 'string') {
+                try {
+                    updateFilter._id = new mongodb_1.ObjectId(existingProject._id);
                 }
-                else if (dbType === 'nosql') {
-                    // For NoSQL, fetch the project to modify its members array
-                    const projectToUpdate = await this.findOne({ _id: projectId });
-                    if (!projectToUpdate || !projectToUpdate.members) {
-                        continue; // Project not found or has no members, try next connection
-                    }
-                    const updatedMembers = projectToUpdate.members.map((member) => {
-                        if (member.userId === userIdToUpdate) {
-                            return { ...member, archived: newArchivedStatus, archivedBy: archivedBy, archivedAt: archivedAt };
-                        }
-                        return member;
-                    });
-                    let objectIdProjectId;
-                    try {
-                        objectIdProjectId = new mongodb_1.ObjectId(projectId);
-                    }
-                    catch (e) {
-                        // If it's not a valid ObjectId string, it might be a UUID from a SQL project.
-                        // In this case, this NoSQL connection won't find it, so we can just continue.
-                        continue;
-                    }
-                    // Update the project with the modified members array
-                    const result = await nosql_1.nosqlAdapter.update(connection, this.tableName, { _id: objectIdProjectId }, { members: updatedMembers });
-                    if (result)
-                        return result;
+                catch (e) {
+                    // If existingProject._id is not a valid ObjectId string, it's an error for NoSQL
+                    return null; // Or throw a more specific error
                 }
             }
             else {
-                // General update logic
-                if (dbType === 'sql') {
-                    if (processedFilter._id) {
-                        processedFilter.id = processedFilter._id;
-                        delete processedFilter._id;
+                updateFilter._id = existingProject._id; // Already an ObjectId or other valid type
+            }
+        }
+        // Handle specific member archiving/unarchiving
+        if (data["members.$.archived"] !== undefined && filter["_id"] && filter["members.userId"]) { // Use original filter for projectId and userIdToUpdate
+            const originalProjectId = filter["_id"]; // Use the original projectId from the request filter
+            const userIdToUpdate = filter["members.userId"];
+            const newArchivedStatus = data["members.$.archived"];
+            const archivedBy = data["members.$.archivedBy"];
+            const archivedAt = data["members.$.archivedAt"];
+            if (dbType === 'sql') {
+                // For SQL, directly update the project_members table
+                const memberUpdateResult = await sql_1.sqlAdapter.update(connection, 'project_members', { projectId: originalProjectId, userId: userIdToUpdate }, // originalProjectId is fine for SQL
+                { archived: newArchivedStatus, archivedBy: archivedBy, archivedAt: archivedAt });
+                // After updating the member, fetch the full project to return
+                if (memberUpdateResult) {
+                    const updatedProject = await this.findOne({ _id: originalProjectId });
+                    return updatedProject;
+                }
+            }
+            else if (dbType === 'nosql') {
+                const projectToUpdate = existingProject; // Already fetched
+                const updatedMembers = projectToUpdate.members.map((member) => {
+                    if (member.userId === userIdToUpdate) {
+                        return { ...member, archived: newArchivedStatus, archivedBy: archivedBy, archivedAt: archivedAt };
                     }
-                    const result = await sql_1.sqlAdapter.update(connection, this.tableName, processedFilter, data);
-                    if (result)
-                        return result;
+                    return member;
+                });
+                let objectIdOriginalProjectId;
+                try {
+                    objectIdOriginalProjectId = new mongodb_1.ObjectId(originalProjectId); // Convert originalProjectId to ObjectId for NoSQL
                 }
-                else if (dbType === 'nosql') {
-                    const result = await nosql_1.nosqlAdapter.update(connection, this.tableName, processedFilter, data);
-                    if (result)
-                        return result;
+                catch (e) {
+                    return null;
                 }
+                const result = await nosql_1.nosqlAdapter.update(connection, this.tableName, { _id: objectIdOriginalProjectId }, { members: updatedMembers });
+                if (result)
+                    return result;
+            }
+        }
+        else {
+            // General update logic
+            // Use the correctly constructed updateFilter
+            if (dbType === 'sql') {
+                const result = await sql_1.sqlAdapter.update(connection, this.tableName, updateFilter, data);
+                if (result)
+                    return result;
+            }
+            else if (dbType === 'nosql') {
+                const result = await nosql_1.nosqlAdapter.update(connection, this.tableName, updateFilter, data);
+                if (result)
+                    return result;
             }
         }
         return null;

package/dist/models/registry.d.ts

@@ -1,3 +1,3 @@
 import { Model } from './Model';
 export declare const defineModel: (name: string, connectionIds: string[], tableName: string) => void;
-export declare const getModel: (name: string) => Model<any>;
+export declare const getModel: (name: string, dbType?: string) => Model<any>;

package/dist/models/registry.js

@@ -7,11 +7,14 @@ const defineModel = (name, connectionIds, tableName) => {
     models[name] = new Model_1.Model(connectionIds, tableName);
 };
 exports.defineModel = defineModel;
-const getModel = (name) => {
+const getModel = (name, dbType) => {
     const model = models[name];
     if (!model) {
         throw new Error(`Model ${name} not defined.`);
     }
+    if (dbType) {
+        return model.useDbType(dbType);
+    }
     return model;
 };
 exports.getModel = getModel;

package/dist/types/index.d.ts

@@ -50,6 +50,7 @@ export interface DatabaseCredential {
     id: string;
     type: DatabaseType;
     connectionString?: string;
+    main?: boolean;
 }
 export interface StreamByConfig {
     storageProviders: {

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "streamby-core",
-  "version": "0.21.2",
-  "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.0",
-    "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.4",
+  "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.0",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
+  },
+  "peerDependencies": {
+    "express": "^4.0.0"
+  }
+}