streamby-core 0.29.11 → 0.31.0

package/dist/adapters/database/connectionManager.js

@@ -43,105 +43,103 @@ const getConnection = (id) => {
 exports.getConnection = getConnection;
 const ensureTablesExist = async (pool) => {
     try {
-        await pool.query(`
-      CREATE SCHEMA IF NOT EXISTS streamby;
-      CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+        await pool.query(`
+      CREATE SCHEMA IF NOT EXISTS streamby;
+      CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
     `);
         // Migrate id column from UUID to TEXT if it was created with the old schema
-        await pool.query(`
-      DO $$ BEGIN
-        ALTER TABLE streamby.projects ALTER COLUMN id TYPE TEXT USING id::text;
-        ALTER TABLE streamby.projects ALTER COLUMN id SET DEFAULT uuid_generate_v4()::text;
-      EXCEPTION WHEN OTHERS THEN NULL; END $$;
+        await pool.query(`
+      DO $$ BEGIN
+        ALTER TABLE streamby.projects ALTER COLUMN id TYPE TEXT USING id::text;
+        ALTER TABLE streamby.projects ALTER COLUMN id SET DEFAULT uuid_generate_v4()::text;
+      EXCEPTION WHEN OTHERS THEN NULL; END $$;
     `);
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.projects (
-        id               TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        name             VARCHAR(255) NOT NULL,
-        description      TEXT,
-        image            TEXT,
-        "allowedOrigin"  JSONB DEFAULT '[]',
-        exports          JSONB DEFAULT '[]',
-        credentials      JSONB DEFAULT '[]',
-        "apiConnections" JSONB DEFAULT '[]',
-        "dbConnections"  JSONB DEFAULT '[]',
-        "dbType"         VARCHAR(50) NOT NULL DEFAULT 'sql',
-        "createdAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "updatedAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-      );
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.projects (
+        id               TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        name             VARCHAR(255) NOT NULL,
+        description      TEXT,
+        image            TEXT,
+        "allowedOrigin"  JSONB DEFAULT '[]',
+        exports          JSONB DEFAULT '[]',
+        connections      JSONB DEFAULT '[]',
+        "dbConnections"  JSONB DEFAULT '[]',
+        "dbType"         VARCHAR(50) NOT NULL DEFAULT 'sql',
+        "createdAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt"      TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
     `);
         console.log('✅ "projects" table ensured to exist.');
         // Add JSONB columns to existing tables that predate this schema version
-        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 "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;
+        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 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;
     `);
         // Ensure dbType exists with a non-null default
-        await pool.query(`
-      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50) NOT NULL DEFAULT 'sql';
+        await pool.query(`
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50) NOT NULL DEFAULT 'sql';
     `);
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.project_members (
-        id           TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        "projectId"  TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
-        "userId"     VARCHAR(255) NOT NULL,
-        role         VARCHAR(255) NOT NULL DEFAULT 'member',
-        status       VARCHAR(50) NOT NULL DEFAULT 'active',
-        archived     BOOLEAN NOT NULL DEFAULT FALSE,
-        "archivedBy" VARCHAR(255),
-        "archivedAt" TIMESTAMP WITH TIME ZONE,
-        "createdAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "updatedAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        UNIQUE ("projectId", "userId")
-      );
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.project_members (
+        id           TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        "projectId"  TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
+        "userId"     VARCHAR(255) NOT NULL,
+        role         VARCHAR(255) NOT NULL DEFAULT 'member',
+        status       VARCHAR(50) NOT NULL DEFAULT 'active',
+        archived     BOOLEAN NOT NULL DEFAULT FALSE,
+        "archivedBy" VARCHAR(255),
+        "archivedAt" TIMESTAMP WITH TIME ZONE,
+        "createdAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        UNIQUE ("projectId", "userId")
+      );
     `);
-        await pool.query(`
-      ALTER TABLE streamby.project_members ADD COLUMN IF NOT EXISTS status VARCHAR(50) NOT NULL DEFAULT 'active';
+        await pool.query(`
+      ALTER TABLE streamby.project_members ADD COLUMN IF NOT EXISTS status VARCHAR(50) NOT NULL DEFAULT 'active';
     `);
         console.log('✅ "project_members" table ensured to exist.');
         // Migrate projectId FK column from UUID to TEXT if table predates this schema version
-        await pool.query(`
-      DO $$ BEGIN
-        ALTER TABLE streamby.project_members DROP CONSTRAINT IF EXISTS project_members_projectId_fkey;
-        ALTER TABLE streamby.project_members ALTER COLUMN "projectId" TYPE TEXT;
-        ALTER TABLE streamby.project_members ADD CONSTRAINT project_members_projectid_fkey
-          FOREIGN KEY ("projectId") REFERENCES streamby.projects(id) ON DELETE CASCADE;
-      EXCEPTION WHEN OTHERS THEN NULL; END $$;
+        await pool.query(`
+      DO $$ BEGIN
+        ALTER TABLE streamby.project_members DROP CONSTRAINT IF EXISTS project_members_projectId_fkey;
+        ALTER TABLE streamby.project_members ALTER COLUMN "projectId" TYPE TEXT;
+        ALTER TABLE streamby.project_members ADD CONSTRAINT project_members_projectid_fkey
+          FOREIGN KEY ("projectId") REFERENCES streamby.projects(id) ON DELETE CASCADE;
+      EXCEPTION WHEN OTHERS THEN NULL; END $$;
     `);
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.exports (
-        id          TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        "projectId" TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
-        status      VARCHAR(50) NOT NULL DEFAULT 'pending',
-        "filePath"  TEXT,
-        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-      );
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.exports (
+        id          TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        "projectId" TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
+        status      VARCHAR(50) NOT NULL DEFAULT 'pending',
+        "filePath"  TEXT,
+        "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
     `);
         console.log('✅ "exports" table ensured to exist.');
         // user_integrations is registered against the main db only (see createRouter.ts), but
         // this function runs per-SQL-connection like projects/exports above — harmless on
         // non-main connections since the model never queries them there.
-        await pool.query(`
-      CREATE TABLE IF NOT EXISTS streamby.user_integrations (
-        id                     TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
-        "userId"               VARCHAR(255) NOT NULL,
-        kind                   VARCHAR(20) NOT NULL,
-        provider               VARCHAR(20) NOT NULL,
-        name                   VARCHAR(255) NOT NULL,
-        description            TEXT,
-        "encryptedCredential"  TEXT NOT NULL,
-        "createdAt"            TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-        "updatedAt"            TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-      );
-      CREATE INDEX IF NOT EXISTS user_integrations_userid_idx ON streamby.user_integrations ("userId");
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS streamby.user_integrations (
+        id                     TEXT PRIMARY KEY DEFAULT uuid_generate_v4()::text,
+        "userId"               VARCHAR(255) NOT NULL,
+        kind                   VARCHAR(20) NOT NULL,
+        provider               VARCHAR(20) NOT NULL,
+        name                   VARCHAR(255) NOT NULL,
+        description            TEXT,
+        "encryptedCredential"  TEXT NOT NULL,
+        "createdAt"            TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        "updatedAt"            TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
+      CREATE INDEX IF NOT EXISTS user_integrations_userid_idx ON streamby.user_integrations ("userId");
     `);
         console.log('✅ "user_integrations" table ensured to exist.');
     }

package/dist/adapters/database/sql.js

@@ -10,7 +10,7 @@ function serializeForPg(v) {
 }
 const createSQLExportTable = async (connection, projectId, exportName, nodeSchema) => {
     const exportId = (0, crypto_1.randomUUID)();
-    await connection.query(`INSERT INTO "exports" (id, "projectId", node_schema, name, method, created_at, updated_at)
+    await connection.query(`INSERT INTO "exports" (id, "projectId", node_schema, name, method, created_at, updated_at)
      VALUES ($1, $2, $3, $4, 'GET', NOW(), NOW())`, [exportId, projectId, nodeSchema ? JSON.stringify(nodeSchema) : null, exportName]);
     return { exportId };
 };

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;

package/dist/middleware/routes/dbConnection.js

@@ -41,6 +41,8 @@ const auth_1 = require("../../utils/auth");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
 const builtinAccess_1 = require("../../utils/builtinAccess");
 const userIntegration_1 = require("../../services/userIntegration");
+const sanitize_1 = require("../../utils/sanitize");
+const encryption_1 = require("../../utils/encryption");
 const dbConnection_1 = require("../../services/dbConnection");
 const VALID_DB_TYPES = ['postgresql', 'mongodb'];
 // `builtinId` is config.databases[].id (e.g. 'mongo'), NOT the DbConnection row's own id —
@@ -78,10 +80,9 @@ async function getDecryptedConnectionString(project, connId) {
     const { decrypt, isEncryptionKeySet } = await Promise.resolve().then(() => __importStar(require('../../utils/encryption')));
     if (!isEncryptionKeySet())
         return { error: 'Encryption key is not set', status: 500 };
-    const credential = project.credentials?.find((c) => c.id === conn.credentialId);
-    if (!credential)
-        return { error: 'Credential not found in project', status: 400 };
-    return { connectionString: decrypt(credential.encryptedValue), conn };
+    if (!conn.encryptedCredential)
+        return { error: 'Connection has no stored credential', status: 400 };
+    return { connectionString: decrypt(conn.encryptedCredential), conn };
 }
 function dbConnectionRouter(config) {
     const router = (0, express_1.Router)();
@@ -95,7 +96,7 @@ function dbConnectionRouter(config) {
                 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' });
-            return res.status(200).json({ data: project.dbConnections || [] });
+            return res.status(200).json({ data: (0, sanitize_1.sanitizeConnections)(project.dbConnections) });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to fetch DB connections', details: err.message });
@@ -108,15 +109,15 @@ function dbConnectionRouter(config) {
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ message: 'Permission denied' });
             }
-            const { name, dbType, credentialId, integrationId, description } = req.body;
+            const { name, dbType, credential, integrationId, description } = req.body;
             if (!name || !dbType) {
                 return res.status(400).json({ message: 'name and dbType are required' });
             }
-            if (!credentialId && !integrationId) {
-                return res.status(400).json({ message: 'Either credentialId or integrationId is required' });
+            if (!credential && !integrationId) {
+                return res.status(400).json({ message: 'Either credential or integrationId is required' });
             }
-            if (credentialId && integrationId) {
-                return res.status(400).json({ message: 'Provide only one of credentialId or integrationId' });
+            if (credential && integrationId) {
+                return res.status(400).json({ message: 'Provide only one of credential or integrationId' });
             }
             if (!VALID_DB_TYPES.includes(dbType)) {
                 return res.status(400).json({ message: `dbType must be one of: ${VALID_DB_TYPES.join(', ')}` });
@@ -126,6 +127,7 @@ function dbConnectionRouter(config) {
                 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' });
+            let encryptedCredential;
             if (integrationId) {
                 const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
                 const integration = await UserIntegrationModel.findOne({ id: integrationId, userId: auth.userId });
@@ -135,23 +137,23 @@ function dbConnectionRouter(config) {
                     return res.status(400).json({ message: 'Integration is not a database integration' });
             }
             else {
-                const credExists = project.credentials?.some((c) => c.id === credentialId);
-                if (!credExists)
-                    return res.status(400).json({ message: 'Credential not found in project' });
+                if (!(0, encryption_1.isEncryptionKeySet)())
+                    return res.status(500).json({ message: 'Encryption key is not set' });
+                encryptedCredential = (0, encryption_1.encrypt)(credential);
             }
             const connection = {
                 id: new mongodb_1.ObjectId().toHexString(),
                 name,
                 dbType,
-                credentialId: credentialId ?? '',
                 projectId: req.params.id,
                 createdAt: new Date(),
                 source: integrationId ? 'integration' : 'manual',
                 ...(integrationId && { integrationId }),
+                ...(encryptedCredential !== undefined && { encryptedCredential }),
                 ...(description !== undefined && { description }),
             };
             await Project.update({ _id: req.params.id }, { $push: { dbConnections: connection } });
-            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 DB connection', details: err.message });

package/dist/middleware/routes/distribution.js

@@ -9,6 +9,7 @@ const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const wsHub_1 = require("../../services/wsHub");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
+const sanitize_1 = require("../../utils/sanitize");
 const crypto_1 = __importDefault(require("crypto"));
 function getDb() {
     const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
@@ -33,7 +34,7 @@ function distributionRouter(_config) {
                 return res.status(404).json({ message: 'Project not found' });
             if (!(0, auth_1.isProjectMember)(project, auth.userId))
                 return res.status(403).json({ message: 'Unauthorized' });
-            res.json({ connections: project.distributionConnections ?? [] });
+            res.json({ connections: (0, sanitize_1.sanitizeConnections)(project.distributionConnections) });
         }
         catch (err) {
             res.status(500).json({ message: err.message });
@@ -43,7 +44,7 @@ function distributionRouter(_config) {
         try {
             const auth = req.auth;
             const { projectId } = req.params;
-            const { name, target, credentialId, config, description } = req.body;
+            const { name, target, encryptedCredential, config, description } = req.body;
             if (!name || !target)
                 return res.status(400).json({ message: 'name and target are required' });
             const project = await Project.findOne({ _id: projectId });
@@ -55,14 +56,14 @@ function distributionRouter(_config) {
                 id: crypto_1.default.randomUUID(),
                 name,
                 target,
-                credentialId,
+                encryptedCredential,
                 config: config ?? {},
                 description,
                 projectId,
                 createdAt: new Date(),
             };
             await Project.update({ _id: projectId }, { $push: { distributionConnections: connection } });
-            res.status(201).json({ connection });
+            res.status(201).json({ connection: (0, sanitize_1.sanitizeConnection)(connection) });
         }
         catch (err) {
             res.status(500).json({ message: err.message });

package/dist/middleware/routes/export.js

@@ -120,19 +120,16 @@ function exportRouter(config) {
                         return res.status(404).json({ message: 'Project not found.' });
                     }
                     let headers = {};
-                    if (exportMetadata.credentialId) {
+                    if (exportMetadata.encryptedCredential) {
                         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) {
-                            const decryptedValue = (0, encryption_1.decrypt)(credential.encryptedValue);
-                            const authPrefix = exportMetadata.prefix ? `${exportMetadata.prefix} ` : '';
-                            headers = {
-                                'Authorization': `${authPrefix}${decryptedValue}`,
-                                'Content-Type': 'application/json',
-                            };
-                        }
+                        const decryptedValue = (0, encryption_1.decrypt)(exportMetadata.encryptedCredential);
+                        const authPrefix = exportMetadata.prefix ? `${exportMetadata.prefix} ` : '';
+                        headers = {
+                            'Authorization': `${authPrefix}${decryptedValue}`,
+                            'Content-Type': 'application/json',
+                        };
                     }
                     const externalApiData = await fetch(exportMetadata.apiUrl, { headers });
                     const apiResponse = await externalApiData.json();
@@ -168,7 +165,7 @@ function exportRouter(config) {
                         createdAt: rawData?.createdAt,
                         updatedAt: rawData?.updatedAt,
                         type: exportMetadata.type,
-                        credentialId: exportMetadata.credentialId,
+                        hasCredential: !!exportMetadata.encryptedCredential,
                         description: rawData?.description,
                         fields: exportMetadata.fields,
                     };
@@ -372,15 +369,11 @@ function exportRouter(config) {
                 }
                 else if (exportMetadata.type === 'externalApi') {
                     let headers = {};
-                    if (exportMetadata.credentialId) {
+                    if (exportMetadata.encryptedCredential) {
                         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 decryptedValue = (0, encryption_1.decrypt)(exportMetadata.encryptedCredential);
                         const authPrefix = exportMetadata.prefix ? `${exportMetadata.prefix} ` : '';
                         headers = {
                             'Authorization': `${authPrefix}${decryptedValue}`,

package/dist/middleware/routes/project.js

@@ -193,7 +193,7 @@ function projectRouter(config) {
                 useConnections: e.useConnections,
                 useCredentials: e.useCredentials,
             }));
-            const sanitized = (0, sanitize_1.sanitizeProject)({ ...project, id: project._id || project.id, _id: undefined, apiConnections: project.apiConnections || [], exports });
+            const sanitized = (0, sanitize_1.sanitizeProject)({ ...project, id: project._id || project.id, _id: undefined, connections: project.connections || [], exports });
             res.json({ project: sanitized, message: 'Project fetched successfully' });
         }
         catch (err) {