streamby-core 0.23.0 → 0.23.2

package/dist/middleware/createRouter.js

@@ -13,6 +13,7 @@ const database_1 = require("./routes/database");
 const storage_2 = require("./routes/storage");
 const project_1 = require("./routes/project");
 const export_1 = require("./routes/export");
+const auth_2 = require("../services/auth");
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
     (0, connectionManager_1.initConnections)(config.databases || []);
@@ -26,6 +27,7 @@ function createStreamByRouter(config) {
             (0, manager_1.registerModel)('users', [mainDb.id], 'users');
         }
     }
+    router.use((0, auth_2.authenticate)(config));
     router.use((0, auth_1.authRouter)(config));
     router.use((0, database_1.databaseRouter)(config));
     router.use((0, storage_2.storageRouter)(config));

package/dist/middleware/public.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from 'express';
+export declare function publicRoute(req: Request, res: Response, next: NextFunction): void;

package/dist/middleware/public.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicRoute = publicRoute;
+function publicRoute(req, res, next) {
+    if (req.path.includes('/public-export/')) {
+        return next();
+    }
+    return next();
+}

package/dist/middleware/routes/export.js

@@ -147,5 +147,85 @@ function exportRouter(config) {
             res.status(500).json({ message: 'Failed to fetch public export data', details: err.message });
         }
     });
+    router.get('/:projectId/public-export/:exportName', async (req, res) => {
+        try {
+            const { projectId, exportName } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project) {
+                return res.status(404).json({ message: 'Project not found' });
+            }
+            const exportMetadata = project.exports.find((e) => e.name === exportName);
+            if (!exportMetadata) {
+                return res.status(404).json({ message: 'Export not found in this project' });
+            }
+            const targetDb = config.databases?.find(db => db.type === project.dbType);
+            if (!targetDb) {
+                return res.status(500).json({ message: `Database connection not found for type ${project.dbType}` });
+            }
+            const connection = (0, connectionManager_1.getConnection)(targetDb.id);
+            let data;
+            if (project.dbType === 'nosql') {
+                const db = connection.client.db();
+                if (exportMetadata.type === 'raw') {
+                    const rawData = await db.collection(exportMetadata.collectionName).findOne({ _id: new mongodb_1.ObjectId(exportMetadata.id) });
+                    data = rawData ? rawData.json : null;
+                }
+                else {
+                    data = await db.collection(exportMetadata.collectionName).find({ __metadata: { $exists: false } }).toArray();
+                }
+            }
+            else if (project.dbType === 'sql') {
+                // SQL implementation for public exports will go here
+                return res.status(501).json({ message: 'SQL public exports not yet implemented' });
+            }
+            if (!data) {
+                return res.status(404).json({ message: 'Export data not found' });
+            }
+            res.json(data); // Return the raw data directly
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch public export data', details: err.message });
+        }
+    });
+    router.get('/:projectId/public-export/:exportName', async (req, res) => {
+        try {
+            const { projectId, exportName } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project) {
+                return res.status(404).json({ message: 'Project not found' });
+            }
+            const exportMetadata = project.exports.find((e) => e.name === exportName);
+            if (!exportMetadata) {
+                return res.status(404).json({ message: 'Export not found in this project' });
+            }
+            const targetDb = config.databases?.find(db => db.type === project.dbType);
+            if (!targetDb) {
+                return res.status(500).json({ message: `Database connection not found for type ${project.dbType}` });
+            }
+            const connection = (0, connectionManager_1.getConnection)(targetDb.id);
+            let data;
+            if (project.dbType === 'nosql') {
+                const db = connection.client.db();
+                if (exportMetadata.type === 'raw') {
+                    const rawData = await db.collection(exportMetadata.collectionName).findOne({ _id: new mongodb_1.ObjectId(exportMetadata.id) });
+                    data = rawData ? rawData.json : null;
+                }
+                else {
+                    data = await db.collection(exportMetadata.collectionName).find({ __metadata: { $exists: false } }).toArray();
+                }
+            }
+            else if (project.dbType === 'sql') {
+                // SQL implementation for public exports will go here
+                return res.status(501).json({ message: 'SQL public exports not yet implemented' });
+            }
+            if (!data) {
+                return res.status(404).json({ message: 'Export data not found' });
+            }
+            res.json(data); // Return the raw data directly
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch public export data', details: err.message });
+        }
+    });
     return router;
 }

package/dist/middleware/routes/project.js

@@ -146,14 +146,14 @@ function projectRouter(config) {
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            await Project.delete({ _id: projectId });
+            await Project.useDbType(project.dbType).delete({ _id: projectId });
             const allProjects = await Project.find({});
             const projects = allProjects
-                .filter(project => {
-                const isMember = project.members?.some((m) => m.userId?.toString() === auth.userId?.toString());
+                .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
             })
-                .map(project => mapProjectToResponseFormat(project, auth.userId));
+                .map(p => mapProjectToResponseFormat(p, auth.userId));
             res.status(200).json({ success: true, projects: projects, message: 'Project deleted successfully' });
         }
         catch (err) {

package/dist/models/Model.js

@@ -34,11 +34,11 @@ class Model {
                 if (this.tableName === 'projects' && processedFilter.members && processedFilter.members.$elemMatch) {
                     // Handle members filter for SQL projects
                     const userId = processedFilter.members.$elemMatch.userId;
-                    const query = `
-            SELECT p.*, pm."userId" as memberUserId, pm.archived as memberArchived
-            FROM "projects" p
-            JOIN "project_members" pm ON p.id = pm."projectId"
-            WHERE pm."userId" = $1
+                    const query = `
+            SELECT p.*, pm."userId" as memberUserId, pm.archived as memberArchived
+            FROM "projects" p
+            JOIN "project_members" pm ON p.id = pm."projectId"
+            WHERE pm."userId" = $1
           `;
                     const result = await connection.query(query, [userId]);
                     sqlResults = result.rows.map(row => ({

package/dist/services/auth.d.ts

@@ -1,5 +1,5 @@
 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 const authenticate: (config: StreamByConfig) => (req: Request, res: Response, next: NextFunction) => Promise<void | Response<any, Record<string, any>>>;
 export declare function checkRole(auth: Auth, required: 'viewer' | 'editor' | 'admin'): void;

package/dist/services/auth.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.authenticate = void 0;
 exports.checkRole = checkRole;
 const authenticate = (config) => async (req, res, next) => {
+    if (req.path.includes('/public-export/')) {
+        return next();
+    }
     try {
         const auth = await config.authProvider(req);
         if (!auth || !auth.userId || !auth.role) {

package/dist/utils/auth.d.ts

@@ -1 +1,2 @@
-export declare function isProjectMember(project: any, userId: string): any;
+import { ProjectInfo } from '../types';
+export declare function isProjectMember(project: ProjectInfo, userId: string): boolean;

package/dist/utils/auth.js

@@ -2,5 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isProjectMember = isProjectMember;
 function isProjectMember(project, userId) {
-    return project.members?.some((m) => m.userId?.toString() === userId?.toString());
+    if (!project || !project.members) {
+        return false;
+    }
+    return project.members.some(member => member.userId === userId);
 }

package/package.json

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