streamby-core 0.21.7 → 0.22.0

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

@@ -1,9 +1,18 @@
 import { MongoClient, Document } from 'mongodb';
+import { FieldDefinition } from '../../types';
 export declare const ensureCollectionsExist: (client: MongoClient) => Promise<void>;
+export declare const createNoSQLExportCollection: (connection: MongoClient, projectId: string, exportName: string, fields: FieldDefinition[]) => Promise<{
+    collectionName: string;
+    exportId: string;
+}>;
+export declare const createNoSQLRawExportCollection: (connection: MongoClient, projectId: string, exportName: string, jsonData: any) => Promise<{
+    collectionName: string;
+    exportId: string;
+}>;
 export declare const nosqlAdapter: {
     find: (connection: MongoClient, tableName: string, filter: any) => Promise<Document[]>;
     findOne: (connection: MongoClient, tableName: string, filter: any) => Promise<Document | null>;
     create: <T extends Document>(connection: MongoClient, tableName: string, data: T) => Promise<T>;
-    update: (connection: MongoClient, tableName: string, filter: any, data: Partial<Document>) => Promise<Document | null>;
+    update: (connection: MongoClient, tableName: string, filter: any, data: Document | Partial<Document>) => Promise<Document | null>;
     delete: (connection: MongoClient, tableName: string, filter: any) => Promise<number>;
 };

package/dist/adapters/database/nosql.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nosqlAdapter = exports.ensureCollectionsExist = void 0;
+exports.nosqlAdapter = exports.createNoSQLRawExportCollection = exports.createNoSQLExportCollection = exports.ensureCollectionsExist = void 0;
 const mongodb_1 = require("mongodb");
 const ensureCollectionsExist = async (client) => {
     const db = client.db();
@@ -16,6 +16,33 @@ const ensureCollectionsExist = async (client) => {
     console.log('✅ "exports" collection ensured to exist.');
 };
 exports.ensureCollectionsExist = ensureCollectionsExist;
+const createNoSQLExportCollection = async (connection, projectId, exportName, fields) => {
+    const db = connection.db();
+    const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    const collectionName = `export_${projectId}_${slug}`;
+    // Create the collection implicitly by inserting the metadata document
+    const metadataDocument = {
+        __metadata: {
+            fields,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        },
+    };
+    await db.collection(collectionName).insertOne(metadataDocument);
+    console.log(`✅ Collection '${collectionName}' created with metadata.`);
+    return { collectionName, exportId: collectionName };
+};
+exports.createNoSQLExportCollection = createNoSQLExportCollection;
+const createNoSQLRawExportCollection = async (connection, projectId, exportName, jsonData) => {
+    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);
+    console.log(`✅ Raw collection '${collectionName}' created with provided JSON data.`);
+    return { collectionName, exportId: collectionName };
+};
+exports.createNoSQLRawExportCollection = createNoSQLRawExportCollection;
 exports.nosqlAdapter = {
     find: async (connection, tableName, filter) => {
         const db = connection.db();
@@ -42,7 +69,10 @@ exports.nosqlAdapter = {
         if (processedFilter._id && typeof processedFilter._id === 'string') {
             processedFilter._id = new mongodb_1.ObjectId(processedFilter._id);
         }
-        const result = await db.collection(tableName).findOneAndUpdate(processedFilter, { $set: data }, { returnDocument: 'after' });
+        // Check if the update data contains MongoDB update operators (e.g., $set, $push)
+        const isUpdateOperator = Object.keys(data).some(key => key.startsWith('$'));
+        const updateDocument = isUpdateOperator ? data : { $set: data };
+        const result = await db.collection(tableName).findOneAndUpdate(processedFilter, updateDocument, { returnDocument: 'after' });
         if (!result) {
             return null;
         }

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

@@ -1,4 +1,13 @@
 import { Pool } from 'pg';
+import { FieldDefinition } from '../../types';
+export declare const createSQLExportTable: (connection: Pool, projectId: string, exportName: string, fields: FieldDefinition[]) => Promise<{
+    collectionName: string;
+    exportId: string;
+}>;
+export declare const createSQLRawExportTable: (connection: Pool, projectId: string, exportName: string, jsonData: any) => Promise<{
+    collectionName: string;
+    exportId: string;
+}>;
 export declare const sqlAdapter: {
     find: (connection: Pool, tableName: string, filter: any) => Promise<any[]>;
     findOne: (connection: Pool, tableName: string, filter: any) => Promise<any | null>;

package/dist/adapters/database/sql.js

@@ -1,6 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sqlAdapter = void 0;
+exports.sqlAdapter = exports.createSQLRawExportTable = exports.createSQLExportTable = void 0;
+const createSQLExportTable = async (connection, projectId, exportName, fields) => {
+    const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    const tableName = `export_${projectId}_${slug}`;
+    const columns = fields.map(field => `"${field.name}" ${field.type}`).join(',');
+    const createTableQuery = `
+    CREATE TABLE IF NOT EXISTS "${tableName}" (
+      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+      "projectId" UUID NOT NULL,
+      __metadata JSONB NOT NULL,
+      ${columns ? `, ${columns}` : ''}
+    );
+  `;
+    await connection.query(createTableQuery);
+    console.log(`✅ Table '${tableName}' created with metadata.`);
+    const metadata = {
+        fields,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    };
+    // Insert metadata as the first row, or a dedicated metadata row
+    // For simplicity, we'll just create the table with the metadata column.
+    // Actual metadata insertion for validation would happen on data inserts.
+    return { collectionName: tableName, exportId: tableName };
+};
+exports.createSQLExportTable = createSQLExportTable;
+const createSQLRawExportTable = async (connection, projectId, exportName, jsonData) => {
+    const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    const tableName = `raw_export_${projectId}_${slug}`;
+    const createTableQuery = `
+    CREATE TABLE IF NOT EXISTS "${tableName}" (
+      id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+      data JSONB NOT NULL
+    );
+  `;
+    await connection.query(createTableQuery);
+    console.log(`✅ Raw table '${tableName}' created.`);
+    // Insert the raw JSON data directly into the new table
+    await connection.query(`INSERT INTO "${tableName}" (data) VALUES ($1)`, [jsonData]);
+    console.log(`✅ Raw JSON data inserted into table '${tableName}'.`);
+    return { collectionName: tableName, exportId: tableName };
+};
+exports.createSQLRawExportTable = createSQLRawExportTable;
 exports.sqlAdapter = {
     find: async (connection, tableName, filter) => {
         const keys = Object.keys(filter);

package/dist/middleware/createRouter.js

@@ -10,7 +10,7 @@ const storage_1 = require("../providers/storage");
 const connectionManager_1 = require("../adapters/database/connectionManager");
 const auth_1 = require("./routes/auth");
 const database_1 = require("./routes/database");
-const file_1 = require("./routes/file");
+const storage_2 = require("./routes/storage");
 const project_1 = require("./routes/project");
 const export_1 = require("./routes/export");
 function createStreamByRouter(config) {
@@ -28,7 +28,7 @@ function createStreamByRouter(config) {
     }
     router.use((0, auth_1.authRouter)(config));
     router.use((0, database_1.databaseRouter)(config));
-    router.use((0, file_1.fileRouter)(config));
+    router.use((0, storage_2.storageRouter)(config));
     router.use((0, project_1.projectRouter)(config));
     router.use((0, export_1.exportRouter)(config));
     return router;

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

@@ -4,32 +4,33 @@ exports.exportRouter = exportRouter;
 const express_1 = require("express");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
+const export_1 = require("../../services/export");
 function exportRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
-    const Export = (0, manager_1.getModel)('exports');
     router.get('/projects/:id/exports/:export_id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
             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 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 } });
+            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,27 +39,46 @@ 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' });
+            const { name, description, collectionName, fields } = req.body;
+            if (!name || !collectionName || !fields) {
+                return res.status(400).json({ message: 'Missing export name, collectionName, or fields' });
             }
             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,
-                description,
-                collectionName,
-                projectId
-            });
-            res.status(201).json({ data: { ...newExport, id: newExport._id || newExport.id, _id: undefined } });
+            const result = await (0, export_1.createExport)(config, projectId, name, collectionName, fields, project.dbType);
+            res.status(201).json({ data: result, message: result.message });
         }
         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 });
+        }
+    });
+    router.post('/projects/:id/exports/raw', async (req, res) => {
+        try {
+            const auth = await config.authProvider(req);
+            if (!auth ||
+                !auth.userId ||
+                !auth.role) {
+                return res.status(401).json({ message: 'Unauthorized' });
+            }
+            const projectId = req.params.id;
+            const { name, description, collectionName, jsonData } = req.body;
+            if (!name || !collectionName || !jsonData) {
+                return res.status(400).json({ message: 'Missing export name, collectionName, or jsonData' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            }
+            const result = await (0, export_1.createRawExport)(config, projectId, name, collectionName, jsonData, project.dbType);
+            res.status(201).json({ data: result, message: result.message });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to create raw export', details: err.message });
         }
     });
     return router;

package/dist/middleware/routes/project.js

@@ -39,29 +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 = 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',
@@ -70,10 +70,17 @@ 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) => {
@@ -82,43 +89,50 @@ function projectRouter(config) {
             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 = 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) => {
@@ -127,16 +141,23 @@ function projectRouter(config) {
             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) => {
@@ -145,7 +166,7 @@ function projectRouter(config) {
             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;
@@ -154,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;
@@ -169,10 +190,10 @@ 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) => {
@@ -181,7 +202,7 @@ function projectRouter(config) {
             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;
@@ -190,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;
@@ -205,10 +226,10 @@ 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) => {
@@ -217,14 +238,14 @@ function projectRouter(config) {
             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);
@@ -237,38 +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 = 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/middleware/routes/{file.d.ts → storage.d.ts}

@@ -1,5 +1,5 @@
 import { Router } from 'express';
 import { StreamByConfig, StorageAdapter } from '../../types';
-export declare function fileRouter(config: StreamByConfig & {
+export declare function storageRouter(config: StreamByConfig & {
     adapter?: StorageAdapter;
 }): Router;

package/dist/middleware/routes/{file.js → storage.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileRouter = fileRouter;
+exports.storageRouter = storageRouter;
 const express_1 = require("express");
 const file_1 = require("../../services/file");
 const presign_1 = require("../../services/presign");
 const storage_1 = require("../../providers/storage");
 const manager_1 = require("../../models/manager");
-function fileRouter(config) {
+function storageRouter(config) {
     const router = (0, express_1.Router)();
     const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
     const Project = (0, manager_1.getModel)('projects');
@@ -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,40 +38,40 @@ 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) => {
+    router.get('/storages', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
             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/services/export.d.ts

@@ -0,0 +1,10 @@
+import { FieldDefinition, DatabaseType } from '../types';
+interface CreateExportResult {
+    exportId: string;
+    collectionName: string;
+    message: string;
+}
+import { StreamByConfig } from '../types';
+export declare function createExport(config: StreamByConfig, projectId: string, exportName: string, collectionName: string, fields: FieldDefinition[], dbType: DatabaseType): Promise<CreateExportResult>;
+export declare function createRawExport(config: StreamByConfig, projectId: string, exportName: string, collectionName: string, jsonData: any, dbType: DatabaseType): Promise<CreateExportResult>;
+export {};

package/dist/services/export.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExport = createExport;
+exports.createRawExport = createRawExport;
+const manager_1 = require("../models/manager");
+const connectionManager_1 = require("../adapters/database/connectionManager");
+const nosql_1 = require("../adapters/database/nosql");
+const sql_1 = require("../adapters/database/sql");
+async function createExport(config, projectId, exportName, collectionName, fields, dbType) {
+    const Project = (0, manager_1.getModel)('projects');
+    const project = await Project.findOne({ _id: projectId });
+    if (!project) {
+        throw new Error('Project not found');
+    }
+    const targetDb = config.databases?.find(db => db.type === dbType && db.main) ||
+        config.databases?.find(db => db.type === dbType);
+    if (!targetDb) {
+        throw new Error(`Database connection not found for type ${dbType}`);
+    }
+    const connection = (0, connectionManager_1.getConnection)(targetDb.id);
+    let result;
+    if (dbType === 'nosql') {
+        result = await (0, nosql_1.createNoSQLExportCollection)(connection.client, projectId, exportName, fields);
+    }
+    else if (dbType === 'sql') {
+        result = await (0, sql_1.createSQLExportTable)(connection.client, projectId, exportName, fields);
+    }
+    else {
+        throw new Error('Unsupported database type');
+    }
+    // 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 } } });
+    return { ...result, message: 'Export created successfully' };
+}
+async function createRawExport(config, projectId, exportName, collectionName, jsonData, dbType) {
+    const targetDb = config.databases?.find(db => db.type === dbType && db.main) ||
+        config.databases?.find(db => db.type === dbType);
+    if (!targetDb) {
+        throw new Error(`Database connection not found for type ${dbType}`);
+    }
+    const connection = (0, connectionManager_1.getConnection)(targetDb.id);
+    let result;
+    if (dbType === 'nosql') {
+        result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, projectId, exportName, jsonData);
+    }
+    else if (dbType === 'sql') {
+        result = await (0, sql_1.createSQLRawExportTable)(connection.client, projectId, exportName, jsonData);
+    }
+    else {
+        throw new Error('Unsupported database type');
+    }
+    // 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 } } });
+    return { ...result, message: 'Raw export created successfully' };
+}

package/dist/types/index.d.ts

@@ -17,6 +17,12 @@ export interface StorageAdapter {
     getPresignedUrl?: (contentType: string, projectId: string) => Promise<any>;
     getPresignedProjectImageUrl?: (projectId: string) => Promise<any>;
 }
+export interface FieldDefinition {
+    name: string;
+    type: string;
+    label: string;
+    required?: boolean;
+}
 export interface ProjectInfo {
     _id?: string;
     id: string;
@@ -74,4 +80,7 @@ export interface Export {
     projectId: string;
     createdAt: Date;
     updatedAt: Date;
+    type: 'structured' | 'raw';
+    fields?: FieldDefinition[];
+    jsonData?: any;
 }

package/package.json

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