streamby-core 0.27.1 → 0.27.3

package/dist/middleware/routes/export.js

@@ -267,7 +267,7 @@ function exportRouter(config) {
             if (!project) {
                 return res.status(404).json({ message: 'Project not found' });
             }
-            const exportMetadata = project.exports.find((e) => e.name === exportName);
+            const exportMetadata = project.exports?.find((e) => e.name?.toLowerCase().trim() === exportName.toLowerCase().trim());
             if (!exportMetadata) {
                 return res.status(404).json({ message: 'Export not found in this project' });
             }
@@ -318,64 +318,62 @@ function exportRouter(config) {
             let data;
             if (exportMetadata.nodeSchema) {
                 data = await (0, pipeline_1.executePipeline)(exportMetadata.nodeSchema, project, config);
+                return res.json(data ?? null);
             }
-            else {
-                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}` });
+            // Legacy path: raw JSON or external API export
+            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);
+            if (project.dbType === 'nosql') {
+                const db = connection.client.db();
+                const legacyCollection = exportMetadata.collectionName ?? projectId;
+                if (exportMetadata.type === 'json') {
+                    const rawData = await db.collection(legacyCollection).findOne({ _id: new mongodb_1.ObjectId(exportMetadata.id.toString()) });
+                    data = rawData ? rawData.json : null;
                 }
-                const connection = (0, connectionManager_1.getConnection)(targetDb.id);
-                if (project.dbType === 'nosql') {
-                    const db = connection.client.db();
-                    if (exportMetadata.type === 'json') {
-                        const rawData = await db.collection(exportMetadata.collectionName).findOne({ _id: new mongodb_1.ObjectId(exportMetadata.id) });
-                        data = rawData ? rawData.json : null;
-                    }
-                    else if (exportMetadata.type === 'externalApi') {
-                        let headers = {};
-                        if (exportMetadata.credentialId) {
-                            if (!(0, encryption_1.isEncryptionKeySet)()) {
-                                throw new Error('Encryption key is not set. Cannot use encrypted credentials.');
-                            }
-                            const credential = project.credentials?.find((cred) => cred.id === exportMetadata.credentialId);
-                            if (!credential) {
-                                throw new Error(`Credential with ID ${exportMetadata.credentialId} not found.`);
-                            }
-                            const decryptedValue = (0, encryption_1.decrypt)(credential.encryptedValue);
-                            const authPrefix = exportMetadata.prefix ? `${exportMetadata.prefix} ` : '';
-                            headers = {
-                                'Authorization': `${authPrefix}${decryptedValue}`,
-                                'Content-Type': 'application/json',
-                            };
-                        }
-                        try {
-                            const response = await fetch(exportMetadata.apiUrl, { headers });
-                            if (!response.ok) {
-                                throw new Error(`Failed to fetch from external API: ${response.statusText}`);
-                            }
-                            data = await response.json();
+                else if (exportMetadata.type === 'externalApi') {
+                    let headers = {};
+                    if (exportMetadata.credentialId) {
+                        if (!(0, encryption_1.isEncryptionKeySet)()) {
+                            throw new Error('Encryption key is not set. Cannot use encrypted credentials.');
                         }
-                        catch (error) {
-                            throw new Error(`Error fetching from external API: ${error.message}`);
+                        const credential = project.credentials?.find((cred) => cred.id === exportMetadata.credentialId);
+                        if (!credential) {
+                            throw new Error(`Credential with ID ${exportMetadata.credentialId} not found.`);
                         }
-                        if (exportMetadata.fields && exportMetadata.fields.length > 0) {
-                            data = data.map((item) => {
-                                return exportMetadata.fields.reduce((filtered, field) => {
-                                    filtered[field.name] = item[field.name];
-                                    return filtered;
-                                }, {});
-                            });
+                        const decryptedValue = (0, encryption_1.decrypt)(credential.encryptedValue);
+                        const authPrefix = exportMetadata.prefix ? `${exportMetadata.prefix} ` : '';
+                        headers = {
+                            'Authorization': `${authPrefix}${decryptedValue}`,
+                            'Content-Type': 'application/json',
+                        };
+                    }
+                    try {
+                        const response = await fetch(exportMetadata.apiUrl, { headers });
+                        if (!response.ok) {
+                            throw new Error(`Failed to fetch from external API: ${response.statusText}`);
                         }
+                        data = await response.json();
+                    }
+                    catch (error) {
+                        throw new Error(`Error fetching from external API: ${error.message}`);
+                    }
+                    if (exportMetadata.fields && exportMetadata.fields.length > 0) {
+                        data = data.map((item) => {
+                            return exportMetadata.fields.reduce((filtered, field) => {
+                                filtered[field.name] = item[field.name];
+                                return filtered;
+                            }, {});
+                        });
                     }
                 }
-                else if (project.dbType === 'sql') {
-                    return res.status(501).json({ message: 'SQL public exports not yet implemented' });
-                }
-            } // end legacy else block
-            if (!data) {
-                return res.status(404).json({ message: 'Export data not found' });
             }
-            res.json(data);
+            else if (project.dbType === 'sql') {
+                return res.status(501).json({ message: 'SQL public exports not yet implemented' });
+            }
+            res.json(data ?? null);
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to fetch public export data', details: err.message });

package/dist/services/export.js

@@ -19,9 +19,11 @@ async function createExport(config, projectId, description, exportName, dbType,
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
     const resolvedDbType = targetDb.type;
     let exportId;
+    let collectionName;
     if (resolvedDbType === 'nosql') {
         const result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, projectId, exportName, 'GET', nodeSchema);
         exportId = result.exportId;
+        collectionName = result.collectionName;
     }
     else if (resolvedDbType === 'sql') {
         const result = await (0, sql_1.createSQLRawExportTable)(connection.client, projectId, exportName, nodeSchema);
@@ -46,9 +48,13 @@ async function createExport(config, projectId, description, exportName, dbType,
         useCredentials,
         description,
         storageDbId: targetDb.id,
+        collectionName,
     };
     const ProjectModel = isSqlProject ? (0, manager_1.getModel)('projects', 'sql') : (0, manager_1.getModel)('projects', 'nosql');
-    await ProjectModel.update({ _id: projectId }, { $push: { exports: exportEntry } });
+    const updated = await ProjectModel.update({ _id: projectId }, { $push: { exports: exportEntry } });
+    if (!updated) {
+        throw new Error(`Failed to save export entry to project ${projectId}. The project may not exist or the database update failed.`);
+    }
     return { exportId, message: `${exportType} export created successfully` };
 }
 async function updateExport(config, projectId, exportId, description, exportName, dbType, exportType, isPrivate, allowedOrigin, devMode, devPorts, nodeSchema, useConnections, useCredentials) {

package/package.json

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