streamby-core 0.25.8 → 0.26.1

package/dist/services/export.js

@@ -8,103 +8,39 @@ 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, projectId, 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, projectId, 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, 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') {
+    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(projectId).updateOne({ _id: new mongodb_1.ObjectId(exportId) }, { $set: { nodeSchema, description, updatedAt: new Date() } });
     }
     else {
         throw new Error('Unsupported database type for update');
@@ -113,11 +49,10 @@ 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) {
@@ -126,7 +61,7 @@ async function deleteExport(config, projectId, exportId, dbType, collectionName)
     const connection = (0, connectionManager_1.getConnection)(targetDb.id);
     if (dbType === 'nosql') {
         const db = connection.client.db();
-        await db.collection(collectionName).deleteOne({ _id: new mongodb_1.ObjectId(exportId) });
+        await db.collection(projectId).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');
+}

package/package.json

@@ -1,61 +1,61 @@
-{
-  "name": "streamby-core",
-  "version": "0.25.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"
-  }
-}
+{
+  "name": "streamby-core",
+  "version": "0.26.1",
+  "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"
+  }
+}