streamby-core 0.25.7 → 0.26.0

package/dist/middleware/routes/member.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memberRouter = memberRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const connectionManager_1 = require("../../adapters/database/connectionManager");
+const sql_1 = require("../../adapters/database/sql");
+const VALID_ROLES = ['viewer', 'editor', 'admin'];
+function memberRouter(config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    const getSqlConnection = () => {
+        const sqlDb = config.databases?.find(db => db.type === 'sql');
+        if (!sqlDb || !(0, connectionManager_1.getConnectedIds)().includes(sqlDb.id))
+            return null;
+        return (0, connectionManager_1.getConnection)(sqlDb.id).client;
+    };
+    router.get('/projects/:id/members', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const projectId = req.params.id;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project) {
+                return res.status(404).json({ message: 'Project not found' });
+            }
+            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            }
+            const mainDb = config.databases?.find(db => db.main);
+            if (!mainDb) {
+                return res.status(500).json({ message: 'Main database not configured' });
+            }
+            const User = (0, manager_1.getModel)('users');
+            const membersWithUsernames = await Promise.all(project.members.map(async (member) => {
+                const user = await User.findOne({ _id: member.userId });
+                return {
+                    userId: member.userId,
+                    username: user ? user.username : 'Unknown',
+                    role: member.role,
+                    profilePic: user ? user.profilePic : '',
+                };
+            }));
+            res.json({ members: membersWithUsernames, message: 'Project members fetched successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch project members', details: err.message });
+        }
+    });
+    router.post('/projects/:id/members', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin') {
+                return res.status(403).json({ message: 'Only admins can invite members' });
+            }
+            const projectId = req.params.id;
+            const { userId, role } = req.body;
+            if (!userId || !role) {
+                return res.status(400).json({ message: 'userId and role are required' });
+            }
+            if (!VALID_ROLES.includes(role)) {
+                return res.status(400).json({ message: `role must be one of: ${VALID_ROLES.join(', ')}` });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project) {
+                return res.status(404).json({ message: 'Project not found' });
+            }
+            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            }
+            const alreadyMember = project.members?.some((m) => m.userId?.toString() === userId?.toString());
+            if (alreadyMember) {
+                return res.status(400).json({ message: 'User is already a member of this project' });
+            }
+            const User = (0, manager_1.getModel)('users');
+            const user = await User.findOne({ _id: userId });
+            if (!user) {
+                return res.status(404).json({ message: 'User not found' });
+            }
+            const newMember = { userId, username: user.username, role, archived: false };
+            if (project.dbType === 'sql') {
+                const connection = getSqlConnection();
+                if (!connection) {
+                    return res.status(503).json({ message: 'SQL connection not available' });
+                }
+                await sql_1.sqlAdapter.create(connection, 'project_members', {
+                    projectId,
+                    userId,
+                    role,
+                    archived: false,
+                }, 'streamby');
+            }
+            else {
+                await Project.update({ _id: projectId }, { $push: { members: newMember } });
+            }
+            res.status(201).json({ member: newMember, message: 'Member invited successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to invite member', details: err.message });
+        }
+    });
+    router.patch('/projects/:id/members/:userId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin') {
+                return res.status(403).json({ message: 'Only admins can update member roles' });
+            }
+            const projectId = req.params.id;
+            const targetUserId = req.params.userId;
+            const { role } = req.body;
+            if (!role || !VALID_ROLES.includes(role)) {
+                return res.status(400).json({ message: `role must be one of: ${VALID_ROLES.join(', ')}` });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project) {
+                return res.status(404).json({ message: 'Project not found' });
+            }
+            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            }
+            const memberExists = project.members?.some((m) => m.userId?.toString() === targetUserId?.toString());
+            if (!memberExists) {
+                return res.status(404).json({ message: 'Member not found in project' });
+            }
+            if (project.dbType === 'sql') {
+                const connection = getSqlConnection();
+                if (!connection) {
+                    return res.status(503).json({ message: 'SQL connection not available' });
+                }
+                await sql_1.sqlAdapter.update(connection, 'project_members', { projectId, userId: targetUserId }, { role }, 'streamby');
+            }
+            else {
+                const updatedMembers = project.members.map((m) => m.userId?.toString() === targetUserId?.toString() ? { ...m, role } : m);
+                await Project.update({ _id: projectId }, { members: updatedMembers });
+            }
+            res.status(200).json({ message: 'Member role updated successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to update member role', details: err.message });
+        }
+    });
+    router.delete('/projects/:id/members/:userId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin') {
+                return res.status(403).json({ message: 'Only admins can remove members' });
+            }
+            const projectId = req.params.id;
+            const targetUserId = req.params.userId;
+            if (targetUserId === auth.userId) {
+                return res.status(400).json({ message: 'Cannot remove yourself from the project' });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project) {
+                return res.status(404).json({ message: 'Project not found' });
+            }
+            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            }
+            const memberExists = project.members?.some((m) => m.userId?.toString() === targetUserId?.toString());
+            if (!memberExists) {
+                return res.status(404).json({ message: 'Member not found in project' });
+            }
+            if (project.dbType === 'sql') {
+                const connection = getSqlConnection();
+                if (!connection) {
+                    return res.status(503).json({ message: 'SQL connection not available' });
+                }
+                await sql_1.sqlAdapter.delete(connection, 'project_members', { projectId, userId: targetUserId }, 'streamby');
+            }
+            else {
+                await Project.update({ _id: projectId }, { $pull: { members: { userId: targetUserId } } });
+            }
+            res.status(200).json({ message: 'Member removed successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to remove member', details: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/project.js

@@ -96,7 +96,16 @@ function projectRouter(config) {
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            res.json({ project: { ...project, id: project._id || project.id, _id: undefined, apiConnections: project.apiConnections || [] }, message: 'Project fetched successfully' });
+            const exports = (project.exports || []).map((e) => ({
+                id: e.id,
+                name: e.name,
+                description: e.description,
+                method: e.method,
+                private: e.private,
+                useConnections: e.useConnections,
+                useCredentials: e.useCredentials,
+            }));
+            res.json({ project: { ...project, id: project._id || project.id, _id: undefined, apiConnections: project.apiConnections || [], exports }, message: 'Project fetched successfully' });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to fetch project', details: err.message });
@@ -234,38 +243,6 @@ function projectRouter(config) {
             res.status(500).json({ message: 'Failed to unarchive project', details: err.message });
         }
     });
-    router.get('/projects/:id/members', async (req, res) => {
-        try {
-            const auth = req.auth;
-            const projectId = req.params.id;
-            const project = await Project.findOne({ _id: projectId });
-            if (!project) {
-                return res.status(404).json({ message: 'Project not found' });
-            }
-            if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
-                return res.status(403).json({ message: 'Unauthorized project access' });
-            }
-            const mainDb = config.databases?.find(db => db.main);
-            if (!mainDb) {
-                return res.status(500).json({ message: 'Main database not configured' });
-            }
-            const userDbType = mainDb.type;
-            const User = (0, manager_1.getModel)('users', userDbType);
-            const membersWithUsernames = await Promise.all(project.members.map(async (member) => {
-                const user = await User.findOne({ _id: member.userId });
-                return {
-                    userId: member.userId,
-                    username: user ? user.username : 'Unknown',
-                    role: member.role,
-                    profilePic: user ? user.profilePic : ''
-                };
-            }));
-            res.json({ members: membersWithUsernames, message: 'Project members fetched successfully' });
-        }
-        catch (err) {
-            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;

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

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

package/dist/middleware/routes/user.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userRouter = userRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+function userRouter(config) {
+    const router = (0, express_1.Router)();
+    const User = (0, manager_1.getModel)('users');
+    router.get('/users/search', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const q = (req.query.q || '').trim();
+            if (!q) {
+                return res.status(400).json({ message: 'Query param q is required' });
+            }
+            const allUsers = await User.find({});
+            const lower = q.toLowerCase();
+            const users = allUsers
+                .filter((u) => u.username?.toLowerCase().includes(lower))
+                .slice(0, 20)
+                .map((u) => ({
+                id: u._id || u.id,
+                username: u.username,
+                profilePic: u.profilePic || '',
+            }));
+            res.json({ users });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to search users', details: err.message });
+        }
+    });
+    return router;
+}

package/dist/models/Model.js

@@ -45,11 +45,11 @@ class Model {
                     // Handle members filter for SQL projects
                     const userId = processedFilter.members.$elemMatch.userId;
                     const schema = this.schema || 'streamby'; // Default to 'streamby' if schema not provided
-                    const query = `
-            SELECT p.*, pm."userId" as memberUserId, pm.archived as memberArchived
-            FROM "${schema}"."projects" p
-            JOIN "${schema}"."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 "${schema}"."projects" p
+            JOIN "${schema}"."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.d.ts

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

package/dist/services/export.js

@@ -8,103 +8,40 @@ 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");
-const encryption_1 = require("../utils/encryption");
-async function createExport(config, projectId, description, fields, exportName, jsonData, dbType, exportType, isPrivate, allowedOrigin, apiUrl, credentialId, prefix) {
+async function createExport(config, projectId, description, exportName, dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials) {
     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 (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);
+    let exportId;
+    if (dbType === 'nosql') {
+        const result = await (0, nosql_1.createNoSQLRawExportCollection)(connection.client, exportName, 'GET', nodeSchema);
+        exportId = result.exportId;
     }
     else if (dbType === 'sql') {
-        result = await (0, sql_1.createSQLRawExportTable)(connection.client, projectId, exportName, jsonData);
+        const result = await (0, sql_1.createSQLRawExportTable)(connection.client, exportName, nodeSchema);
+        exportId = result.exportId;
     }
     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: 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, description: description, fields: fields } } });
-    return { ...result, message: `${exportType} export created successfully` };
+    await NoSQLProject.update({ _id: projectId }, { $push: { exports: { id: new mongodb_1.ObjectId(exportId), name: exportName, type: exportType, method: 'GET', private: isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials, description } } });
+    return { exportId, message: `${exportType} export created successfully` };
 }
-async function updateExport(config, projectId, exportId, description, fields, exportName, collectionName, jsonData, dbType, exportType, isPrivate, allowedOrigin, apiUrl, credentialId, prefix) {
+async function updateExport(config, projectId, exportId, description, exportName, storedExportName, dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials) {
     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 (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,
-                description: description,
-                fields: fields,
-                updatedAt: new Date(),
-                apiUrl: apiUrl,
-                credentialId: credentialId,
-                prefix: prefix,
-            };
-            await db.collection(collectionName).updateOne({ _id: new mongodb_1.ObjectId(exportId) }, { $set: updateData });
-        }
-        else {
-            throw new Error('Unsupported database type for externalApi export update');
-        }
-    }
-    else if (dbType === 'nosql') {
+    const storedSlug = storedExportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    if (dbType === 'nosql') {
         const db = connection.client.db();
-        const updateData = {
-            json: jsonData,
-            description: description,
-            fields: fields,
-            apiUrl: apiUrl,
-            credentialId: credentialId,
-            prefix: prefix,
-        };
-        await db.collection(collectionName).updateOne({ _id: new mongodb_1.ObjectId(exportId) }, { $set: updateData });
+        await db.collection(storedSlug).updateOne({ _id: new mongodb_1.ObjectId(exportId) }, { $set: { nodeSchema, description, updatedAt: new Date() } });
     }
     else {
         throw new Error('Unsupported database type for update');
@@ -113,20 +50,20 @@ async function updateExport(config, projectId, exportId, description, fields, ex
     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, 'exports.$.apiUrl': apiUrl, 'exports.$.credentialId': credentialId, 'exports.$.prefix': prefix, 'exports.$.description': description, 'exports.$.fields': fields } });
-    result = { collectionName, exportId };
-    return { ...result, message: `${exportType} export updated successfully` };
+    }, { $set: { 'exports.$.name': exportName, 'exports.$.private': isPrivate, 'exports.$.allowedOrigin': allowedOrigin, 'exports.$.nodeSchema': nodeSchema, 'exports.$.useConnections': useConnections, 'exports.$.useCredentials': useCredentials, 'exports.$.description': description } });
+    return { exportId, message: `${exportType} export updated successfully` };
 }
-async function deleteExport(config, projectId, exportId, dbType, collectionName) {
+async function deleteExport(config, projectId, exportId, dbType, exportName) {
     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);
+    const slug = exportName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     if (dbType === 'nosql') {
         const db = connection.client.db();
-        await db.collection(collectionName).deleteOne({ _id: new mongodb_1.ObjectId(exportId) });
+        await db.collection(slug).deleteOne({ _id: new mongodb_1.ObjectId(exportId) });
     }
     else {
         throw new Error('Unsupported database type for delete');

package/dist/services/pipeline.d.ts

@@ -0,0 +1,2 @@
+import { NodeSchema, StreamByConfig } from '../types';
+export declare function executePipeline(nodeSchema: NodeSchema, project: any, config: StreamByConfig): Promise<any>;

package/dist/services/pipeline.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executePipeline = executePipeline;
+const connectionManager_1 = require("../adapters/database/connectionManager");
+const encryption_1 = require("../utils/encryption");
+function getSources(nodes, edges, targetId, targetHandle) {
+    return edges
+        .filter(e => e.target === targetId && e.targetHandle === targetHandle)
+        .map(e => nodes.find(n => n.id === e.source))
+        .filter((n) => n !== undefined);
+}
+function getTarget(nodes, edges, sourceId, sourceHandle) {
+    const edge = edges.find(e => e.source === sourceId && e.sourceHandle === sourceHandle);
+    return edge ? (nodes.find(n => n.id === edge.target) ?? null) : null;
+}
+async function executePipeline(nodeSchema, project, config) {
+    const nodes = nodeSchema.nodes;
+    const edges = nodeSchema.edges;
+    // 1. Data layer — nodes connected to streamby in-bottom
+    const dataSources = getSources(nodes, edges, 'streamby', 'in-bottom');
+    const dataResults = [];
+    for (const node of dataSources) {
+        if (node.type === 'jsonInputNode') {
+            try {
+                dataResults.push(JSON.parse(node.data?.jsonString || 'null'));
+            }
+            catch {
+                dataResults.push(null);
+            }
+        }
+        else if (node.type === 'dataSourceNode') {
+            const collectionName = node.data?.subtitle || node.data?.label;
+            if (!collectionName)
+                continue;
+            const targetDb = config.databases?.find(db => db.type === project.dbType && db.main)
+                ?? config.databases?.find(db => db.type === project.dbType);
+            if (!targetDb)
+                throw new Error(`No database connection for type ${project.dbType}`);
+            const connection = (0, connectionManager_1.getConnection)(targetDb.id);
+            const db = connection.client.db();
+            dataResults.push(await db.collection(collectionName).find({}).toArray());
+        }
+        else if (node.type === 'apiConnectionNode') {
+            const apiConnection = project.apiConnections?.find((c) => c.id === node.data?.connectionId);
+            if (!apiConnection)
+                continue;
+            const headers = { 'Content-Type': 'application/json' };
+            if (apiConnection.credentialId && (0, encryption_1.isEncryptionKeySet)()) {
+                const credential = project.credentials?.find((c) => c.id === apiConnection.credentialId);
+                if (credential) {
+                    const decrypted = (0, encryption_1.decrypt)(credential.encryptedValue);
+                    const prefix = apiConnection.prefix ? `${apiConnection.prefix} ` : '';
+                    headers['Authorization'] = `${prefix}${decrypted}`;
+                }
+            }
+            const response = await fetch(apiConnection.baseUrl, { method: apiConnection.method || 'GET', headers });
+            if (!response.ok)
+                throw new Error(`API connection fetch failed: ${response.statusText}`);
+            dataResults.push(await response.json());
+        }
+    }
+    let payload = dataResults.length === 1 ? dataResults[0] : dataResults;
+    // 2. Process layer — chain from streamby out-top → processNode in-process → out-process → ...
+    let processNode = getTarget(nodes, edges, 'streamby', 'out-top');
+    while (processNode) {
+        // transform/auth/custom logic per processNode.data.label — pass-through until defined
+        processNode = getTarget(nodes, edges, processNode.id, 'out-process');
+    }
+    // 3. Filter layer — chain from streamby out-right → filterNode in-filter → out-filter → ...
+    let filterNode = getTarget(nodes, edges, 'streamby', 'out-right');
+    while (filterNode) {
+        // filter logic per filterNode.data.label — pass-through until defined
+        filterNode = getTarget(nodes, edges, filterNode.id, 'out-filter');
+    }
+    return payload;
+}

package/dist/types/index.d.ts

@@ -106,19 +106,25 @@ export interface Auth {
     role: 'viewer' | 'editor' | 'admin';
 }
 export type AuthProvider = (req: Request) => Promise<Auth>;
+export interface NodeSchema {
+    nodes: any[];
+    edges: any[];
+}
 export interface Export {
     _id?: string;
     id: string;
-    collectionName: string;
     projectId: string;
     createdAt: Date;
     updatedAt: Date;
-    type: 'json' | 'externalApi';
+    type?: 'json' | 'externalApi';
     fields?: FieldDefinition[];
     jsonData?: any;
-    private?: boolean;
-    allowedOrigin?: string[];
     apiUrl?: string;
     credentialId?: string;
     prefix?: string;
+    private?: boolean;
+    allowedOrigin?: string[];
+    nodeSchema?: NodeSchema;
+    useConnections?: boolean;
+    useCredentials?: boolean;
 }

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');
+}