streamby-core 0.29.2 → 0.29.4

package/dist/middleware/routes/connection.js

@@ -102,6 +102,44 @@ function connectionRouter(config) {
             res.status(500).json({ message: 'Failed to add API connection', details: err.message });
         }
     });
+    // Update an API connection (name, url, method, prefix, credentialId, description)
+    router.patch('/projects/:id/connections/api/:connectionId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const { id: projectId, connectionId } = req.params;
+            const { name, apiUrl, method, description, credentialId, prefix } = req.body;
+            if (method && !VALID_METHODS.includes(method)) {
+                return res.status(400).json({ message: `method must be one of: ${VALID_METHODS.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' });
+            }
+            if (credentialId) {
+                const credExists = project.credentials?.some((c) => c.id === credentialId);
+                if (!credExists) {
+                    return res.status(400).json({ message: 'Credential not found in project' });
+                }
+            }
+            const updated = await (0, apiConnection_1.updateApiConnection)(config, projectId, connectionId, {
+                ...(name !== undefined && { name }),
+                ...(apiUrl !== undefined && { apiUrl }),
+                ...(method !== undefined && { method }),
+                ...(description !== undefined && { description }),
+                ...(prefix !== undefined && { prefix }),
+                ...(credentialId !== undefined && { credentialId }),
+            });
+            return res.status(200).json({ data: updated });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to update API connection', details: err.message });
+        }
+    });
     // Execute the request represented by an API connection
     router.get('/projects/:id/get-connection/:connectionId', async (req, res) => {
         try {

package/dist/middleware/routes/export.js

@@ -12,32 +12,49 @@ const encryption_1 = require("../../utils/encryption");
 const DEFAULT_NODE_SCHEMA = {
     nodes: [
         {
-            id: 'client',
-            type: 'clientNode',
+            id: 'request',
+            type: 'requestNode',
             position: { x: 0, y: 100 },
-            data: { label: 'Client', subtitle: 'GET' },
+            data: { label: 'Request', subtitle: 'GET' },
             width: 148,
             height: 100,
         },
         {
             id: 'streamby',
             type: 'streambyNode',
-            position: { x: 240, y: 100 },
+            position: { x: 280, y: 100 },
             data: { label: 'StreamBy', subtitle: 'Middleware' },
             width: 158,
             height: 100,
         },
+        {
+            id: 'response',
+            type: 'responseNode',
+            position: { x: 560, y: 100 },
+            data: { label: 'Response', subtitle: 'HTTP Response' },
+            width: 148,
+            height: 100,
+        },
     ],
     edges: [
         {
-            id: 'e-client-streamby',
-            source: 'client',
+            id: 'e-request-streamby',
+            source: 'request',
             sourceHandle: 'out-right',
             target: 'streamby',
             targetHandle: 'in-left',
             animated: true,
             style: { stroke: '#38B6FF', strokeWidth: 2 },
         },
+        {
+            id: 'e-streamby-response',
+            source: 'streamby',
+            sourceHandle: 'out-right',
+            target: 'response',
+            targetHandle: 'in-left',
+            animated: true,
+            style: { stroke: '#fbbf24', strokeWidth: 2 },
+        },
     ],
 };
 function exportRouter(config) {

package/dist/services/apiConnection.d.ts

@@ -7,4 +7,12 @@ export declare function addApiConnection(config: StreamByConfig, projectId: stri
     description?: string;
     credentialId?: string;
 }): Promise<ApiConnection>;
+export declare function updateApiConnection(config: StreamByConfig, projectId: string, connectionId: string, data: {
+    name?: string;
+    apiUrl?: string;
+    method?: ApiConnectionMethod;
+    prefix?: string;
+    description?: string;
+    credentialId?: string;
+}): Promise<ApiConnection>;
 export declare function deleteApiConnection(config: StreamByConfig, projectId: string, connectionId: string): Promise<void>;

package/dist/services/apiConnection.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addApiConnection = addApiConnection;
+exports.updateApiConnection = updateApiConnection;
 exports.deleteApiConnection = deleteApiConnection;
 const mongodb_1 = require("mongodb");
 const manager_1 = require("../models/manager");
@@ -27,6 +28,30 @@ async function addApiConnection(config, projectId, data) {
     }
     return connection;
 }
+async function updateApiConnection(config, projectId, connectionId, data) {
+    const ProjectModel = (0, manager_1.getModel)('projects');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project)
+        throw new Error('Project not found.');
+    const connections = project.apiConnections ?? [];
+    const index = connections.findIndex((c) => c.id === connectionId);
+    if (index === -1)
+        throw new Error('API connection not found.');
+    const updated = {
+        ...connections[index],
+        ...(data.name !== undefined && { name: data.name }),
+        ...(data.apiUrl !== undefined && { apiUrl: data.apiUrl }),
+        ...(data.method !== undefined && { method: data.method }),
+        ...(data.prefix !== undefined && { prefix: data.prefix }),
+        ...(data.description !== undefined && { description: data.description }),
+        ...(data.credentialId !== undefined && { credentialId: data.credentialId }),
+    };
+    connections[index] = updated;
+    const result = await ProjectModel.update({ _id: projectId }, { $set: { apiConnections: connections } });
+    if (!result)
+        throw new Error('Failed to update API connection.');
+    return updated;
+}
 async function deleteApiConnection(config, projectId, connectionId) {
     const ProjectModel = (0, manager_1.getModel)('projects');
     const project = await ProjectModel.findOne({ _id: projectId });

package/package.json

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