streamby-core 0.29.12 → 0.32.0

package/dist/adapters/database/connectionManager.js

@@ -62,8 +62,7 @@ const ensureTablesExist = async (pool) => {
         image            TEXT,
         "allowedOrigin"  JSONB DEFAULT '[]',
         exports          JSONB DEFAULT '[]',
-        credentials      JSONB DEFAULT '[]',
-        "apiConnections" JSONB DEFAULT '[]',
+        connections      JSONB DEFAULT '[]',
         "dbConnections"  JSONB DEFAULT '[]',
         "dbType"         VARCHAR(50) NOT NULL DEFAULT 'sql',
         "createdAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
@@ -75,13 +74,17 @@ const ensureTablesExist = async (pool) => {
         await pool.query(`
       ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "allowedOrigin"     JSONB DEFAULT '[]';
       ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS exports             JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS credentials         JSONB DEFAULT '[]';
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "apiConnections"    JSONB DEFAULT '[]';
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS connections         JSONB DEFAULT '[]';
       ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbConnections"     JSONB DEFAULT '[]';
       ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "storageConnections" JSONB DEFAULT '[]';
       ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS workflow            JSONB;
       ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS pipelines           JSONB DEFAULT '[]';
       ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "builtinBackfilledAt" TIMESTAMP WITH TIME ZONE;
+      -- Reverted: a project has no notion of a "default" database/storage connection —
+      -- each dataSourceNode/ingestNode always declares its own connection explicitly.
+      ALTER TABLE streamby.projects DROP COLUMN IF EXISTS "defaultDatabaseId";
+      ALTER TABLE streamby.projects DROP COLUMN IF EXISTS "defaultStorageId";
+      ALTER TABLE streamby.projects DROP COLUMN IF EXISTS "defaultConnectionsBackfilledAt";
     `);
         // Ensure dbType exists with a non-null default
         await pool.query(`

package/dist/middleware/createRouter.js

@@ -19,7 +19,6 @@ const member_1 = require("./routes/member");
 const storage_2 = require("./routes/storage");
 const project_1 = require("./routes/project");
 const database_1 = require("./routes/database");
-const credential_1 = require("./routes/credential");
 const connection_1 = require("./routes/connection");
 const dbConnection_1 = require("./routes/dbConnection");
 const storageConnection_1 = require("./routes/storageConnection");
@@ -98,7 +97,6 @@ function createStreamByRouter(config) {
     router.use((0, storage_2.storageRouter)(config));
     router.use((0, project_1.projectRouter)(config));
     router.use((0, database_1.databaseRouter)(config));
-    router.use((0, credential_1.credentialRouter)(config));
     router.use((0, connection_1.connectionRouter)(config));
     router.use((0, dbConnection_1.dbConnectionRouter)(config));
     router.use((0, storageConnection_1.storageConnectionRouter)(config));

package/dist/middleware/routes/ai.js

@@ -7,7 +7,7 @@ const auth_1 = require("../../utils/auth");
 const jobQueue_1 = require("../../services/jobQueue");
 const aiProcessor_1 = require("../../services/aiProcessor");
 const AVAILABLE_NODE_TYPES = [
-    'dataSourceNode', 'jsonInputNode', 'apiConnectionNode',
+    'dataSourceNode', 'jsonInputNode', 'connectionNode',
     'processNode', 'filterNode',
     'ingestNode', 'transcodeNode', 'captionNode', 'thumbnailNode',
     'renderJobNode', 'formatConvertNode', 'lodNode', 'assetDependencyNode',

package/dist/middleware/routes/connection.js

@@ -37,13 +37,14 @@ exports.connectionRouter = connectionRouter;
 const express_1 = require("express");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
-const apiConnection_1 = require("../../services/apiConnection");
+const connection_1 = require("../../services/connection");
+const sanitize_1 = require("../../utils/sanitize");
 const VALID_METHODS = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE'];
 function connectionRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
-    // List API connections for a project
-    router.get('/projects/:id/connections/api', async (req, res) => {
+    // List connections for a project
+    router.get('/projects/:id/connections', async (req, res) => {
         try {
             const auth = req.auth;
             const projectId = req.params.id;
@@ -54,21 +55,21 @@ function connectionRouter(config) {
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            return res.status(200).json({ data: project.apiConnections || [] });
+            return res.status(200).json({ data: (0, sanitize_1.sanitizeConnections)(project.connections) });
         }
         catch (err) {
-            res.status(500).json({ message: 'Failed to fetch API connections', details: err.message });
+            res.status(500).json({ message: 'Failed to fetch connections', details: err.message });
         }
     });
-    // Add a new API connection to a project
-    router.post('/projects/:id/connections/api', async (req, res) => {
+    // Add a new connection to a project
+    router.post('/projects/:id/connections', 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 { name, apiUrl, method, description, credentialId, prefix } = req.body;
+            const { name, apiUrl, method, description, token, prefix } = req.body;
             if (!name || !apiUrl) {
                 return res.status(400).json({ message: 'name and apiUrl are required' });
             }
@@ -82,35 +83,29 @@ function connectionRouter(config) {
             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 connection = await (0, apiConnection_1.addApiConnection)(config, projectId, {
+            const connection = await (0, connection_1.addConnection)(config, projectId, {
                 name,
                 apiUrl,
                 method,
                 prefix,
                 ...(description !== undefined && { description }),
-                ...(credentialId !== undefined && { credentialId }),
+                ...(token !== undefined && { token }),
             });
-            return res.status(201).json({ data: connection });
+            return res.status(201).json({ data: (0, sanitize_1.sanitizeConnection)(connection) });
         }
         catch (err) {
-            res.status(500).json({ message: 'Failed to add API connection', details: err.message });
+            res.status(500).json({ message: 'Failed to add connection', details: err.message });
         }
     });
-    // Update an API connection (name, url, method, prefix, credentialId, description)
-    router.patch('/projects/:id/connections/api/:connectionId', async (req, res) => {
+    // Update a connection (name, url, method, prefix, token, description)
+    router.patch('/projects/:id/connections/: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;
+            const { name, apiUrl, method, description, token, prefix } = req.body;
             if (method && !VALID_METHODS.includes(method)) {
                 return res.status(400).json({ message: `method must be one of: ${VALID_METHODS.join(', ')}` });
             }
@@ -120,27 +115,21 @@ function connectionRouter(config) {
             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, {
+            const updated = await (0, connection_1.updateConnection)(config, projectId, connectionId, {
                 ...(name !== undefined && { name }),
                 ...(apiUrl !== undefined && { apiUrl }),
                 ...(method !== undefined && { method }),
                 ...(description !== undefined && { description }),
                 ...(prefix !== undefined && { prefix }),
-                ...(credentialId !== undefined && { credentialId }),
+                ...(token !== undefined && { token }),
             });
-            return res.status(200).json({ data: updated });
+            return res.status(200).json({ data: (0, sanitize_1.sanitizeConnection)(updated) });
         }
         catch (err) {
-            res.status(500).json({ message: 'Failed to update API connection', details: err.message });
+            res.status(500).json({ message: 'Failed to update connection', details: err.message });
         }
     });
-    // Execute the request represented by an API connection
+    // Execute the request represented by a connection
     router.get('/projects/:id/get-connection/:connectionId', async (req, res) => {
         try {
             const auth = req.auth;
@@ -152,25 +141,21 @@ function connectionRouter(config) {
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            const apiConnection = project.apiConnections?.find((c) => c.id === connectionId);
-            if (!apiConnection) {
-                return res.status(404).json({ message: 'API connection not found' });
+            const connection = project.connections?.find((c) => c.id === connectionId);
+            if (!connection) {
+                return res.status(404).json({ message: 'Connection not found' });
             }
             const headers = { 'Content-Type': 'application/json' };
-            if (apiConnection.credentialId) {
+            if (connection.encryptedCredential) {
                 const { decrypt, isEncryptionKeySet } = await Promise.resolve().then(() => __importStar(require('../../utils/encryption')));
                 if (!isEncryptionKeySet()) {
                     return res.status(500).json({ message: 'Encryption key is not set' });
                 }
-                const credential = project.credentials?.find((c) => c.id === apiConnection.credentialId);
-                if (!credential) {
-                    return res.status(400).json({ message: 'Credential not found in project' });
-                }
-                const decrypted = decrypt(credential.encryptedValue);
-                const prefix = apiConnection.prefix ? `${apiConnection.prefix} ` : '';
+                const decrypted = decrypt(connection.encryptedCredential);
+                const prefix = connection.prefix ? `${connection.prefix} ` : '';
                 headers['Authorization'] = `${prefix}${decrypted}`;
             }
-            const response = await fetch(apiConnection.apiUrl, { method: apiConnection.method || 'GET', headers });
+            const response = await fetch(connection.apiUrl, { method: connection.method || 'GET', headers });
             if (!response.ok) {
                 return res.status(response.status).json({ message: `External API error: ${response.statusText}` });
             }
@@ -181,8 +166,8 @@ function connectionRouter(config) {
             res.status(500).json({ message: 'Failed to fetch connection data', details: err.message });
         }
     });
-    // Delete an API connection from a project
-    router.delete('/projects/:id/connections/api/:connectionId', async (req, res) => {
+    // Delete a connection from a project
+    router.delete('/projects/:id/connections/:connectionId', async (req, res) => {
         try {
             const auth = req.auth;
             if (auth.role !== 'admin' && auth.role !== 'editor') {
@@ -197,15 +182,15 @@ function connectionRouter(config) {
             if (!(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             }
-            const exists = project.apiConnections?.some((c) => c.id === connectionId);
+            const exists = project.connections?.some((c) => c.id === connectionId);
             if (!exists) {
-                return res.status(404).json({ message: 'API connection not found' });
+                return res.status(404).json({ message: 'Connection not found' });
             }
-            await (0, apiConnection_1.deleteApiConnection)(config, projectId, connectionId);
-            return res.status(200).json({ message: 'API connection deleted successfully.' });
+            await (0, connection_1.deleteConnection)(config, projectId, connectionId);
+            return res.status(200).json({ message: 'Connection deleted successfully.' });
         }
         catch (err) {
-            res.status(500).json({ message: 'Failed to delete API connection', details: err.message });
+            res.status(500).json({ message: 'Failed to delete connection', details: err.message });
         }
     });
     return router;