streamby-core 0.24.5 → 0.24.8

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, method: string) => Promise<{
+export declare const createNoSQLRawExportCollection: (connection: MongoClient, projectId: string, exportName: string, method: string, jsonData?: any) => Promise<{
     collectionName: string;
     exportId: string;
 }>;

package/dist/adapters/database/nosql.js

@@ -33,7 +33,7 @@ const createNoSQLExportCollection = async (connection, projectId, exportName, fi
     return { collectionName, exportId: collectionName };
 };
 exports.createNoSQLExportCollection = createNoSQLExportCollection;
-const createNoSQLRawExportCollection = async (connection, projectId, exportName, jsonData, method) => {
+const createNoSQLRawExportCollection = async (connection, projectId, exportName, method, jsonData) => {
     const db = connection.db();
     const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     const collectionName = `raw_export_${projectId}_${slug}`;

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

@@ -4,7 +4,7 @@ export declare const createSQLExportTable: (connection: Pool, projectId: string,
     collectionName: string;
     exportId: string;
 }>;
-export declare const createSQLRawExportTable: (connection: Pool, projectId: string, exportName: string, jsonData: any) => Promise<{
+export declare const createSQLRawExportTable: (connection: Pool, projectId: string, exportName: string, jsonData?: any) => Promise<{
     collectionName: string;
     exportId: string;
 }>;

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 credential_1 = require("./routes/credential");
 const auth_2 = require("../services/auth");
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
@@ -35,5 +36,6 @@ function createStreamByRouter(config) {
     router.use((0, storage_2.storageRouter)(config));
     router.use((0, project_1.projectRouter)(config));
     router.use((0, export_1.exportRouter)(config));
+    router.use((0, credential_1.credentialRouter)(config));
     return router;
 }

package/dist/middleware/routes/credential.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import { StreamByConfig } from '../../types';
+export declare function credentialRouter(config: StreamByConfig): Router;

package/dist/middleware/routes/credential.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.credentialRouter = credentialRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const credential_1 = require("../../services/credential");
+function credentialRouter(config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // Add a new credential to a project
+    router.post('/projects/:id/credentials', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const { id, key, value } = req.body;
+            if (!key || !value) {
+                return res.status(400).json({ message: 'Missing credential key or value' });
+            }
+            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 updatedProject = await (0, credential_1.addCredential)(config, projectId, { id, key, value });
+            res.status(201).json({ message: 'Credential added successfully', project: updatedProject });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to add credential', details: err.message });
+        }
+    });
+    // Update an existing credential in a project
+    router.patch('/projects/:id/credentials/:credentialId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const credentialId = req.params.credentialId;
+            const { key, value } = req.body;
+            if (!key && !value) {
+                return res.status(400).json({ message: 'No update fields provided' });
+            }
+            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 updatedProject = await (0, credential_1.updateCredential)(config, projectId, credentialId, { key, value });
+            res.status(200).json({ message: 'Credential updated successfully', project: updatedProject });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to update credential', details: err.message });
+        }
+    });
+    // Delete a credential from a project
+    router.delete('/projects/:id/credentials/:credentialId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const credentialId = req.params.credentialId;
+            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 updatedProject = await (0, credential_1.deleteCredential)(config, projectId, credentialId);
+            res.status(200).json({ message: 'Credential deleted successfully', project: updatedProject });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete credential', details: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/export.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exportRouter = exportRouter;
 const express_1 = require("express");
@@ -7,6 +10,8 @@ const auth_1 = require("../../utils/auth");
 const export_1 = require("../../services/export");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
 const mongodb_1 = require("mongodb");
+const encryption_1 = require("../../utils/encryption");
+const node_fetch_1 = __importDefault(require("node-fetch")); // Import fetch here
 function exportRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
@@ -43,6 +48,37 @@ function exportRouter(config) {
                     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 if (exportMetadata.type === 'externalApi') {
+                    const ProjectModel = (0, manager_1.getModel)('projects', 'nosql');
+                    const currentProject = await ProjectModel.findOne({ _id: projectId });
+                    if (!currentProject) {
+                        return res.status(404).json({ message: 'Project not found.' });
+                    }
+                    let headers = {};
+                    if (exportMetadata.credentialId) {
+                        const credential = currentProject.credentials?.find((cred) => cred.id === exportMetadata.credentialId);
+                        if (!credential) {
+                            return res.status(404).json({ message: `Credential with ID ${exportMetadata.credentialId} not found.` });
+                        }
+                        const decryptedValue = (0, encryption_1.decrypt)(credential.encryptedValue);
+                        const authPrefix = exportMetadata.prefix ? `${exportMetadata.prefix} ` : 'Bearer ';
+                        headers = {
+                            'Authorization': `${authPrefix}${decryptedValue}`,
+                            'Content-Type': 'application/json',
+                        };
+                    }
+                    try {
+                        const response = await (0, node_fetch_1.default)(exportMetadata.apiUrl, { headers });
+                        if (!response.ok) {
+                            throw new Error(`Failed to fetch from external API: ${response.statusText}`);
+                        }
+                        const responseData = await response.json();
+                        data = { responseData, name: exportMetadata.name, createdAt: exportMetadata.createdAt, updatedAt: exportMetadata.updatedAt, type: exportMetadata.type, collectionName: exportMetadata.collectionName };
+                    }
+                    catch (error) {
+                        return res.status(500).json({ message: 'Failed to fetch from external API', details: error.message });
+                    }
+                }
                 else {
                     data = await db.collection(exportMetadata.collectionName).find({ __metadata: { $exists: false } }).toArray();
                 }
@@ -86,15 +122,23 @@ function exportRouter(config) {
                 return res.status(401).json({ message: 'Unauthorized' });
             }
             const projectId = req.params.id;
-            const { name, description, collectionName, jsonData, isPrivate, allowedOrigin } = req.body;
-            if (!name || !collectionName || !jsonData) {
-                return res.status(400).json({ message: 'Missing export name, collectionName, or jsonData' });
+            const { name, description, collectionName, jsonData, isPrivate, allowedOrigin, exportType, apiUrl, credentialId, prefix } = req.body;
+            if (!name || !collectionName) {
+                return res.status(400).json({ message: 'Missing export name or collectionName' });
+            }
+            if (exportType === 'externalApi') {
+                if (!apiUrl) {
+                    return res.status(400).json({ message: 'API URL is required for externalApi export type' });
+                }
+            }
+            else if (!jsonData) {
+                return res.status(400).json({ message: 'Missing jsonData for non-externalApi export types' });
             }
             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.createExport)(config, projectId, name, collectionName, jsonData, project.dbType, isPrivate, allowedOrigin);
+            const result = await (0, export_1.createExport)(config, projectId, name, collectionName, jsonData, project.dbType, exportType || 'raw', isPrivate, allowedOrigin, apiUrl, credentialId, prefix);
             res.status(201).json({ data: result, message: result.message });
         }
         catch (err) {
@@ -108,15 +152,23 @@ function exportRouter(config) {
                 return res.status(401).json({ message: 'Unauthorized' });
             }
             const { id: projectId, export_id: exportId } = req.params;
-            const { name, collectionName, description, jsonData, isPrivate, allowedOrigin } = req.body;
-            if (!name || !collectionName || !jsonData) {
-                return res.status(400).json({ message: 'Missing name, collectionName, or jsonData' });
+            const { name, collectionName, description, jsonData, isPrivate, allowedOrigin, exportType, apiUrl, credentialId, prefix } = req.body;
+            if (!name || !collectionName) {
+                return res.status(400).json({ message: 'Missing name or collectionName' });
+            }
+            if (exportType === 'externalApi') {
+                if (!apiUrl) {
+                    return res.status(400).json({ message: 'API URL is required for externalApi export type' });
+                }
+            }
+            else if (!jsonData) {
+                return res.status(400).json({ message: 'Missing jsonData for non-externalApi export types' });
             }
             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.updateExport)(config, projectId, exportId, name, collectionName, jsonData, project.dbType, isPrivate, allowedOrigin);
+            const result = await (0, export_1.updateExport)(config, projectId, exportId, name, collectionName, jsonData, project.dbType, exportType || 'raw', isPrivate, allowedOrigin, apiUrl, credentialId, prefix);
             res.status(200).json({ data: result, message: result.message });
         }
         catch (err) {
@@ -158,15 +210,25 @@ function exportRouter(config) {
             }
             const origin = req.headers.origin;
             let effectiveAllowedOrigins = exportMetadata.allowedOrigin;
-            // If export's allowedOrigin is ['*'] or it's not set, use the project's settings.
+            const projectOrigins = project.allowedOrigin;
+            // If export's allowedOrigin is ['*'] or it's not set, it inherits from the project.
             if (!effectiveAllowedOrigins || (effectiveAllowedOrigins.length === 1 && effectiveAllowedOrigins[0] === '*')) {
-                effectiveAllowedOrigins = project.allowedOrigin;
+                effectiveAllowedOrigins = projectOrigins;
+            }
+            else {
+                // If the export has its own list, ensure it's a subset of the project's list (if project is not public).
+                if (projectOrigins && !projectOrigins.includes('*')) {
+                    const isSubset = effectiveAllowedOrigins.every((o) => projectOrigins.includes(o));
+                    if (!isSubset) {
+                        return res.status(403).json({ message: 'Unauthorized: Export origins are not allowed by the parent project.' });
+                    }
+                }
             }
-            // If there's no origin, deny access unless it's public.
+            // If there's no origin header, deny access unless the effective scope is public.
             if (!origin && !(effectiveAllowedOrigins && effectiveAllowedOrigins.includes('*'))) {
                 return res.status(403).json({ message: 'Origin header required' });
             }
-            // Check for public access ('*') or if the origin is in the list.
+            // Check for public access ('*') or if the request's origin is in the effective list.
             const isAllowed = effectiveAllowedOrigins && (effectiveAllowedOrigins.includes('*') || (origin && effectiveAllowedOrigins.includes(origin)));
             if (!isAllowed) {
                 return res.status(403).json({ message: 'Unauthorized' });
@@ -183,8 +245,33 @@ function exportRouter(config) {
                     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 (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 (0, node_fetch_1.default)(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}`);
+                    }
                 }
             }
             else if (project.dbType === 'sql') {

package/dist/middleware/routes/project.js

@@ -69,7 +69,7 @@ function projectRouter(config) {
                 description: description || '',
                 image: image || '',
                 allowedOrigin: allowedOrigin || [],
-                members: [{ userId: auth.userId, username: user.username, role: "admin", archived: false }]
+                members: [{ userId: auth.userId, username: user.username, role: "admin", archived: false }],
             });
             const allProjects = await Project.find({});
             const projects = allProjects

package/dist/services/credential.d.ts

@@ -0,0 +1,8 @@
+import { StreamByConfig, Credential, ProjectInfo } from '../types';
+export declare function addCredential(config: StreamByConfig, projectId: string, newCredential: Omit<Credential, 'encryptedValue'> & {
+    value: string;
+}): Promise<ProjectInfo>;
+export declare function updateCredential(config: StreamByConfig, projectId: string, credentialId: string, updates: Partial<Omit<Credential, 'encryptedValue'> & {
+    value: string;
+}>): Promise<ProjectInfo>;
+export declare function deleteCredential(config: StreamByConfig, projectId: string, credentialId: string): Promise<ProjectInfo>;

package/dist/services/credential.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCredential = addCredential;
+exports.updateCredential = updateCredential;
+exports.deleteCredential = deleteCredential;
+const manager_1 = require("../models/manager");
+const encryption_1 = require("../utils/encryption");
+const mongodb_1 = require("mongodb");
+async function addCredential(config, projectId, newCredential) {
+    if (!(0, encryption_1.isEncryptionKeySet)()) {
+        throw new Error('Encryption key is not set. Cannot add credentials.');
+    }
+    const ProjectModel = (0, manager_1.getModel)('projects', 'nosql');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project) {
+        throw new Error('Project not found.');
+    }
+    const encryptedValue = (0, encryption_1.encrypt)(newCredential.value);
+    const credentialToSave = {
+        id: newCredential.id || new mongodb_1.ObjectId().toHexString(), // Generate ID if not provided
+        key: newCredential.key,
+        encryptedValue: encryptedValue,
+    };
+    const updatedProject = await ProjectModel.update({ _id: projectId }, { $push: { credentials: credentialToSave } });
+    if (!updatedProject) {
+        throw new Error('Failed to add credential to project.');
+    }
+    return updatedProject;
+}
+async function updateCredential(config, projectId, credentialId, updates) {
+    if (!(0, encryption_1.isEncryptionKeySet)()) {
+        throw new Error('Encryption key is not set. Cannot update credentials.');
+    }
+    const ProjectModel = (0, manager_1.getModel)('projects', 'nosql');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project) {
+        throw new Error('Project not found.');
+    }
+    const credentialIndex = project.credentials?.findIndex(cred => cred.id === credentialId);
+    if (credentialIndex === undefined || credentialIndex === -1) {
+        throw new Error(`Credential with ID ${credentialId} not found.`);
+    }
+    const currentCredential = project.credentials[credentialIndex];
+    let encryptedValue = currentCredential.encryptedValue;
+    if (updates.value !== undefined) {
+        encryptedValue = (0, encryption_1.encrypt)(updates.value);
+    }
+    const updatedCredential = {
+        ...currentCredential,
+        key: updates.key || currentCredential.key,
+        encryptedValue: encryptedValue,
+    };
+    const updatedProject = await ProjectModel.update({ _id: projectId, 'credentials.id': credentialId }, { $set: { 'credentials.$': updatedCredential } });
+    if (!updatedProject) {
+        throw new Error('Failed to update credential in project.');
+    }
+    return updatedProject;
+}
+async function deleteCredential(config, projectId, credentialId) {
+    const ProjectModel = (0, manager_1.getModel)('projects', 'nosql');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project) {
+        throw new Error('Project not found.');
+    }
+    const updatedProject = await ProjectModel.update({ _id: projectId }, { $pull: { credentials: { id: credentialId } } });
+    if (!updatedProject) {
+        throw new Error('Failed to delete credential from project.');
+    }
+    return updatedProject;
+}

package/dist/services/export.d.ts

@@ -1,12 +1,11 @@
-import { DatabaseType } from '../types';
+import { DatabaseType, StreamByConfig } 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, jsonData: any, dbType: DatabaseType, isPrivate?: boolean, allowedOrigin?: string[]): Promise<CreateExportResult>;
-export declare function updateExport(config: StreamByConfig, projectId: string, exportId: string, exportName: string, collectionName: string, jsonData: any, dbType: DatabaseType, isPrivate?: boolean, allowedOrigin?: string[]): Promise<CreateExportResult>;
+export declare function createExport(config: StreamByConfig, projectId: string, exportName: string, collectionName: string, jsonData: any, dbType: DatabaseType, exportType: 'structured' | 'raw' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], apiUrl?: string, credentialId?: string, prefix?: string): Promise<CreateExportResult>;
+export declare function updateExport(config: StreamByConfig, projectId: string, exportId: string, exportName: string, collectionName: string, jsonData: any, dbType: DatabaseType, exportType: 'structured' | 'raw' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], apiUrl?: string, credentialId?: string, prefix?: string): Promise<CreateExportResult>;
 export declare function deleteExport(config: StreamByConfig, projectId: string, exportId: string, dbType: DatabaseType, collectionName: string): Promise<{
     message: string;
 }>;

package/dist/services/export.js

@@ -8,7 +8,8 @@ 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");
-async function createExport(config, projectId, exportName, collectionName, jsonData, dbType, isPrivate, allowedOrigin) {
+const encryption_1 = require("../utils/encryption");
+async function createExport(config, projectId, exportName, collectionName, jsonData, dbType, exportType, isPrivate, allowedOrigin, apiUrl, credentialId, prefix) {
     const targetDb = config.databases?.find(db => db.type === dbType && db.main) ||
         config.databases?.find(db => db.type === dbType);
     if (!targetDb) {
@@ -16,8 +17,36 @@ async function createExport(config, projectId, exportName, collectionName, jsonD
     }
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
     let result;
-    if (dbType === 'nosql') {
-        result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, projectId, exportName, jsonData, 'GET');
+    if (exportType === 'externalApi') {
+        if (!apiUrl) {
+            throw new Error('API URL is required for externalApi export type.');
+        }
+        const ProjectModel = (0, manager_1.getModel)('projects', 'nosql');
+        const project = await ProjectModel.findOne({ _id: projectId });
+        if (!project) {
+            throw new Error('Project not found.');
+        }
+        if (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 === credentialId);
+            if (!credential) {
+                throw new Error(`Credential with ID ${credentialId} not found.`);
+            }
+        }
+        if (dbType === 'nosql') {
+            result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, projectId, exportName, 'GET', null);
+        }
+        else if (dbType === 'sql') {
+            result = await (0, sql_1.createSQLRawExportTable)(connection.client, projectId, exportName, null);
+        }
+        else {
+            throw new Error('Unsupported database type for externalApi export');
+        }
+    }
+    else if (dbType === 'nosql') {
+        result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, projectId, exportName, 'GET', jsonData);
     }
     else if (dbType === 'sql') {
         result = await (0, sql_1.createSQLRawExportTable)(connection.client, projectId, exportName, jsonData);
@@ -28,10 +57,10 @@ async function createExport(config, projectId, exportName, collectionName, jsonD
     // 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: dbType === 'nosql' ? new mongodb_1.ObjectId(result.exportId) : result.exportId, name: exportName, collectionName: result.collectionName, type: 'raw', method: 'GET', private: isPrivate, allowedOrigin: allowedOrigin } } });
-    return { ...result, message: 'Raw export created successfully' };
+    await NoSQLProject.update({ _id: projectId }, { $push: { exports: { id: dbType === 'nosql' ? new mongodb_1.ObjectId(result.exportId) : result.exportId, name: exportName, collectionName: result.collectionName, type: exportType, method: 'GET', private: isPrivate, allowedOrigin: allowedOrigin, apiUrl: apiUrl, credentialId: credentialId, prefix: prefix } } });
+    return { ...result, message: `${exportType} export created successfully` };
 }
-async function updateExport(config, projectId, exportId, exportName, collectionName, jsonData, dbType, isPrivate, allowedOrigin) {
+async function updateExport(config, projectId, exportId, exportName, collectionName, jsonData, dbType, exportType, isPrivate, allowedOrigin, apiUrl, credentialId, prefix) {
     const targetDb = config.databases?.find(db => db.type === dbType && db.main) ||
         config.databases?.find(db => db.type === dbType);
     if (!targetDb) {
@@ -39,7 +68,33 @@ async function updateExport(config, projectId, exportId, exportName, collectionN
     }
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
     let result;
-    if (dbType === 'nosql') {
+    if (exportType === 'externalApi') {
+        if (!apiUrl) {
+            throw new Error('API URL is required for externalApi export type.');
+        }
+        const ProjectModel = (0, manager_1.getModel)('projects', 'nosql');
+        const project = await ProjectModel.findOne({ _id: projectId });
+        if (!project) {
+            throw new Error('Project not found.');
+        }
+        if (dbType === 'nosql') {
+            const db = connection.client.db();
+            const updateData = {
+                json: jsonData,
+                name: exportName,
+                updatedAt: new Date(),
+                apiUrl: apiUrl,
+                credentialId: credentialId,
+                prefix: prefix,
+            };
+            await db.collection(collectionName).updateOne({ _id: new mongodb_1.ObjectId(exportId) }, { $set: updateData });
+            result = { collectionName, exportId };
+        }
+        else {
+            throw new Error('Unsupported database type for externalApi export update');
+        }
+    }
+    else if (dbType === 'nosql') {
         const db = connection.client.db();
         const updateData = {
             json: jsonData,
@@ -56,8 +111,8 @@ async function updateExport(config, projectId, exportId, exportName, collectionN
     await NoSQLProject.update({
         _id: new mongodb_1.ObjectId(projectId),
         'exports.id': { $in: [new mongodb_1.ObjectId(exportId), exportId] }
-    }, { $set: { 'exports.$.name': exportName, 'exports.$.collectionName': collectionName, 'exports.$.private': isPrivate, 'exports.$.allowedOrigin': allowedOrigin } });
-    return { ...result, message: 'Raw export updated successfully' };
+    }, { $set: { 'exports.$.name': exportName, 'exports.$.collectionName': collectionName, 'exports.$.private': isPrivate, 'exports.$.allowedOrigin': allowedOrigin, 'exports.$.apiUrl': apiUrl, 'exports.$.credentialId': credentialId, 'exports.$.prefix': prefix } });
+    return { ...result, message: `${exportType} export updated successfully` };
 }
 async function deleteExport(config, projectId, exportId, dbType, collectionName) {
     const targetDb = config.databases?.find(db => db.type === dbType && db.main) ||

package/dist/types/index.d.ts

@@ -43,6 +43,12 @@ export interface ProjectInfo {
         allowUpload?: boolean;
         allowSharing?: boolean;
     };
+    credentials?: Credential[];
+}
+export interface Credential {
+    id: string;
+    key: string;
+    encryptedValue: string;
 }
 export interface ProjectListInfo {
     id: string;
@@ -80,9 +86,12 @@ export interface Export {
     projectId: string;
     createdAt: Date;
     updatedAt: Date;
-    type: 'structured' | 'raw';
+    type: 'structured' | 'raw' | 'externalApi';
     fields?: FieldDefinition[];
     jsonData?: any;
     private?: boolean;
     allowedOrigin?: string[];
+    apiUrl?: string;
+    credentialId?: string;
+    prefix?: string;
 }

package/dist/utils/crypto.d.ts

@@ -0,0 +1,3 @@
+export declare function encrypt(text: string, secretKey: string): string;
+export declare function decrypt(text: string, secretKey: string): string;
+export declare function hash(text: string): string;

package/dist/utils/crypto.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = encrypt;
+exports.decrypt = decrypt;
+exports.hash = hash;
+const crypto_1 = __importDefault(require("crypto"));
+const ALGORITHM = 'aes-256-cbc';
+const IV_LENGTH = 16;
+function encrypt(text, secretKey) {
+    const iv = crypto_1.default.randomBytes(IV_LENGTH);
+    const key = crypto_1.default.createHash('sha256').update(String(secretKey)).digest('base64').substr(0, 32);
+    const cipher = crypto_1.default.createCipheriv(ALGORITHM, Buffer.from(key), iv);
+    let encrypted = cipher.update(text);
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    return iv.toString('hex') + ':' + encrypted.toString('hex');
+}
+function decrypt(text, secretKey) {
+    const textParts = text.split(':');
+    const iv = Buffer.from(textParts.shift(), 'hex');
+    const encryptedText = Buffer.from(textParts.join(':'), 'hex');
+    const key = crypto_1.default.createHash('sha256').update(String(secretKey)).digest('base64').substr(0, 32);
+    const decipher = crypto_1.default.createDecipheriv(ALGORITHM, Buffer.from(key), iv);
+    let decrypted = decipher.update(encryptedText);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    return decrypted.toString();
+}
+function hash(text) {
+    return crypto_1.default.createHash('sha256').update(text).digest('hex');
+}

package/dist/utils/encryption.d.ts

@@ -0,0 +1,4 @@
+export declare const setEncryptionKey: (key: string) => void;
+export declare const encrypt: (text: string) => string;
+export declare const decrypt: (text: string) => string;
+export declare const isEncryptionKeySet: () => boolean;

package/dist/utils/encryption.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEncryptionKeySet = exports.decrypt = exports.encrypt = exports.setEncryptionKey = void 0;
+const crypto = __importStar(require("crypto"));
+const ALGORITHM = 'aes-256-cbc';
+const IV_LENGTH = 16; // For AES, this is always 16
+let ENCRYPTION_KEY = process.env.STREAMBY_ENCRYPTION_KEY;
+const setEncryptionKey = (key) => {
+    if (key.length !== 64) { // 32 bytes * 2 hex characters per byte
+        throw new Error('Invalid encryption key length. Key must be 32 bytes (64 hexadecimal characters).');
+    }
+    ENCRYPTION_KEY = key;
+};
+exports.setEncryptionKey = setEncryptionKey;
+const encrypt = (text) => {
+    if (!ENCRYPTION_KEY) {
+        throw new Error('Encryption key is not set. Cannot encrypt credentials.');
+    }
+    const iv = crypto.randomBytes(IV_LENGTH);
+    const cipher = crypto.createCipheriv(ALGORITHM, Buffer.from(ENCRYPTION_KEY, 'hex'), iv);
+    let encrypted = cipher.update(text);
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    return iv.toString('hex') + ':' + encrypted.toString('hex');
+};
+exports.encrypt = encrypt;
+const decrypt = (text) => {
+    if (!ENCRYPTION_KEY) {
+        throw new Error('Encryption key is not set. Cannot decrypt credentials.');
+    }
+    const textParts = text.split(':');
+    const iv = Buffer.from(textParts.shift(), 'hex');
+    const encryptedText = Buffer.from(textParts.join(':'), 'hex');
+    const decipher = crypto.createDecipheriv(ALGORITHM, Buffer.from(ENCRYPTION_KEY, 'hex'), iv);
+    let decrypted = decipher.update(encryptedText);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    return decrypted.toString();
+};
+exports.decrypt = decrypt;
+const isEncryptionKeySet = () => {
+    return !!ENCRYPTION_KEY;
+};
+exports.isEncryptionKeySet = isEncryptionKeySet;

package/package.json

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