streamby-core 0.22.0 → 0.23.1

package/dist/adapters/database/nosql.d.ts

@@ -5,7 +5,7 @@ export declare const createNoSQLExportCollection: (connection: MongoClient, proj
     collectionName: string;
     exportId: string;
 }>;
-export declare const createNoSQLRawExportCollection: (connection: MongoClient, projectId: string, exportName: string, jsonData: any) => Promise<{
+export declare const createNoSQLRawExportCollection: (connection: MongoClient, projectId: string, exportName: string, jsonData: any, method: string) => Promise<{
     collectionName: string;
     exportId: string;
 }>;

package/dist/adapters/database/nosql.js

@@ -33,14 +33,14 @@ const createNoSQLExportCollection = async (connection, projectId, exportName, fi
     return { collectionName, exportId: collectionName };
 };
 exports.createNoSQLExportCollection = createNoSQLExportCollection;
-const createNoSQLRawExportCollection = async (connection, projectId, exportName, jsonData) => {
+const createNoSQLRawExportCollection = async (connection, projectId, exportName, jsonData, method) => {
     const db = connection.db();
     const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     const collectionName = `raw_export_${projectId}_${slug}`;
     // Insert the raw JSON data directly into the new collection
-    await db.collection(collectionName).insertOne(jsonData);
+    const result = await db.collection(collectionName).insertOne({ json: jsonData, name: exportName, method, collectionName, createdAt: new Date(), updatedAt: new Date() });
     console.log(`✅ Raw collection '${collectionName}' created with provided JSON data.`);
-    return { collectionName, exportId: collectionName };
+    return { collectionName, exportId: result.insertedId.toHexString() };
 };
 exports.createNoSQLRawExportCollection = createNoSQLRawExportCollection;
 exports.nosqlAdapter = {

package/dist/middleware/routes/export.js

@@ -5,6 +5,8 @@ const express_1 = require("express");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const export_1 = require("../../services/export");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
+const mongodb_1 = require("mongodb");
 function exportRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
@@ -25,9 +27,33 @@ function exportRouter(config) {
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized access' });
             }
-            const Export = (0, manager_1.getModel)('exports', project.dbType);
-            const data = await Export.findOne({ _id: exportId });
-            res.json({ data: { ...data, id: data._id || data.id, _id: undefined }, message: 'Export data fetched successfully' });
+            const exportMetadata = project.exports.find((e) => e.id.toString() === exportId);
+            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(exportId) });
+                    data = rawData ? { json: rawData.json, name: rawData.name, method: rawData.method, collectionName: rawData.collectionName, createdAt: rawData.createdAt, updatedAt: rawData.updatedAt, type: exportMetadata.type } : null;
+                }
+                else {
+                    data = await db.collection(exportMetadata.collectionName).find({ __metadata: { $exists: false } }).toArray();
+                }
+            }
+            else if (project.dbType === 'sql') {
+                // ... SQL implementation needed
+            }
+            if (!data) {
+                return res.status(404).json({ message: 'Export data not found' });
+            }
+            res.json({ data, message: 'Export data fetched successfully' });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to fetch export data', details: err.message });
@@ -81,5 +107,45 @@ function exportRouter(config) {
             res.status(500).json({ message: 'Failed to create raw export', 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/export.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createExport = createExport;
 exports.createRawExport = createRawExport;
 const manager_1 = require("../models/manager");
+const mongodb_1 = require("mongodb");
 const connectionManager_1 = require("../adapters/database/connectionManager");
 const nosql_1 = require("../adapters/database/nosql");
 const sql_1 = require("../adapters/database/sql");
@@ -31,7 +32,7 @@ async function createExport(config, projectId, exportName, collectionName, field
     // Update the project with the new export reference
     // Assuming project metadata is always in NoSQL (MongoDB)
     const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
-    await NoSQLProject.update({ _id: projectId }, { $push: { exports: { id: result.exportId, collectionName: result.collectionName, type: 'structured', fields } } });
+    await NoSQLProject.update({ _id: projectId }, { $push: { exports: { id: result.exportId, collectionName: result.collectionName, type: 'structured', fields, method: 'GET' } } });
     return { ...result, message: 'Export created successfully' };
 }
 async function createRawExport(config, projectId, exportName, collectionName, jsonData, dbType) {
@@ -43,7 +44,7 @@ async function createRawExport(config, projectId, exportName, collectionName, js
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
     let result;
     if (dbType === 'nosql') {
-        result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, projectId, exportName, jsonData);
+        result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, projectId, exportName, jsonData, 'GET');
     }
     else if (dbType === 'sql') {
         result = await (0, sql_1.createSQLRawExportTable)(connection.client, projectId, exportName, jsonData);
@@ -54,6 +55,6 @@ async function createRawExport(config, projectId, exportName, collectionName, js
     // Update the project with the new export reference
     // Assuming project metadata is always in NoSQL (MongoDB)
     const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
-    await NoSQLProject.update({ _id: projectId }, { $push: { exports: { id: result.exportId, collectionName: result.collectionName, type: 'raw', jsonData } } });
+    await NoSQLProject.update({ _id: projectId }, { $push: { exports: { id: dbType === 'nosql' ? new mongodb_1.ObjectId(result.exportId) : result.exportId, name: exportName, collectionName: result.collectionName, type: 'raw', method: 'GET' } } });
     return { ...result, message: 'Raw export created successfully' };
 }

package/package.json

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