streamby-core 0.29.12 → 0.32.0

package/dist/middleware/routes/dbConnection.js

@@ -1,87 +1,31 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dbConnectionRouter = dbConnectionRouter;
 const express_1 = require("express");
 const mongodb_1 = require("mongodb");
 const manager_1 = require("../../models/manager");
 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 connectionResolver_1 = require("../../services/connectionResolver");
 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 —
-// those are different values since TCORE-69's backfill gives each row its own UUID.
-function resolveBuiltinConnection(builtinId, config) {
-    const db = (config.databases ?? []).find(d => d.id === builtinId);
-    if (!db)
-        return { error: `Database '${builtinId}' not found in config`, status: 404 };
-    try {
-        const { client, type } = (0, connectionManager_1.getConnection)(builtinId);
-        return { client: client, dbType: type };
+// Resolves the client for `connId`, runs `fn`, and writes the response — releasing
+// ephemeral (non-builtin) clients afterward. Builtin clients are pooled and owned by
+// connectionManager, never closed here. Responds with the resolve error directly if
+// resolution fails, so callers never have to distinguish an error shape from fn's result.
+async function withResolvedDbClient(project, connId, config, auth, res, fn) {
+    const resolved = await (0, connectionResolver_1.resolveDbConnectionClient)(project, connId, config, auth);
+    if ('error' in resolved) {
+        res.status(resolved.status).json({ message: resolved.error });
+        return;
     }
-    catch (e) {
-        return { error: e.message, status: 503 };
+    try {
+        await fn(resolved);
     }
-}
-// Finds the connection row + classifies it. A row is builtin iff conn.source === 'builtin'
-// (persisted at creation/backfill time) — NOT by comparing the row's own id against
-// config.databases, which no longer holds since builtin rows get their own generated id.
-function findDbConnection(project, connId) {
-    return project.dbConnections?.find((c) => c.id === connId);
-}
-async function getDecryptedConnectionString(project, connId) {
-    const conn = project.dbConnections?.find((c) => c.id === connId);
-    if (!conn)
-        return { error: 'DB connection not found', status: 404 };
-    if (conn.source === 'integration') {
-        if (!conn.integrationId)
-            return { error: 'Connection is missing its integrationId', status: 500 };
-        const credential = await (0, userIntegration_1.getDecryptedIntegrationCredentialById)(conn.integrationId);
-        if (!credential)
-            return { error: 'Integration not found', status: 400 };
-        return { connectionString: credential, conn };
+    finally {
+        await (0, connectionResolver_1.releaseDbClient)(resolved);
     }
-    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 };
 }
 function dbConnectionRouter(config) {
     const router = (0, express_1.Router)();
@@ -95,7 +39,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 +52,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 +70,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 +80,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 });
@@ -169,7 +114,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' });
-            const conn = findDbConnection(project, req.params.connId);
+            const conn = (0, connectionResolver_1.findDbConnection)(project, req.params.connId);
             if (!conn)
                 return res.status(404).json({ message: 'DB connection not found' });
             if (conn.source === 'builtin') {
@@ -191,25 +136,10 @@ 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' });
-            const conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                const tables = await (0, dbConnection_1.listTablesInternal)(internal.client, internal.dbType, req.params.id);
-                return res.status(200).json({ data: tables });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            const tables = await (0, dbConnection_1.listTablesOrCollections)(resolved.connectionString, resolved.conn.dbType);
-            return res.status(200).json({ data: tables });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                const tables = await (0, dbConnection_1.listTablesInternal)(resolved.client, resolved.type, req.params.id);
+                res.status(200).json({ data: tables });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to list tables', details: err.message });
@@ -230,31 +160,14 @@ function dbConnectionRouter(config) {
             const schema = req.body;
             if (!schema.tableName)
                 return res.status(400).json({ message: 'tableName is required' });
-            const conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                if (internal.dbType === 'sql' && (!Array.isArray(schema.columns) || schema.columns.length === 0)) {
-                    return res.status(400).json({ message: 'columns are required for SQL tables' });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                if (resolved.type === 'sql' && (!Array.isArray(schema.columns) || schema.columns.length === 0)) {
+                    res.status(400).json({ message: 'columns are required for SQL tables' });
+                    return;
                 }
-                await (0, dbConnection_1.createTableOrCollectionInternal)(internal.client, internal.dbType, schema, req.params.id);
-                return res.status(201).json({ message: `${internal.dbType === 'sql' ? 'Table' : 'Collection'} created successfully` });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            if (resolved.conn.dbType === 'postgresql' && (!Array.isArray(schema.columns) || schema.columns.length === 0)) {
-                return res.status(400).json({ message: 'columns are required for PostgreSQL tables' });
-            }
-            await (0, dbConnection_1.createTableOrCollection)(resolved.connectionString, resolved.conn.dbType, schema);
-            return res.status(201).json({ message: `${resolved.conn.dbType === 'postgresql' ? 'Table' : 'Collection'} created successfully` });
+                await (0, dbConnection_1.createTableOrCollectionInternal)(resolved.client, resolved.type, schema, req.params.id);
+                res.status(201).json({ message: `${resolved.type === 'sql' ? 'Table' : 'Collection'} created successfully` });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to create table/collection', details: err.message });
@@ -272,25 +185,10 @@ 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' });
-            const conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                await (0, dbConnection_1.deleteTableOrCollectionInternal)(internal.client, internal.dbType, req.params.tableName, req.params.id);
-                return res.status(200).json({ message: 'Table/collection deleted' });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            await (0, dbConnection_1.deleteTableOrCollection)(resolved.connectionString, resolved.conn.dbType, req.params.tableName);
-            return res.status(200).json({ message: 'Table/collection deleted' });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                await (0, dbConnection_1.deleteTableOrCollectionInternal)(resolved.client, resolved.type, req.params.tableName, req.params.id);
+                res.status(200).json({ message: 'Table/collection deleted' });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to delete table/collection', details: err.message });
@@ -307,25 +205,10 @@ function dbConnectionRouter(config) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
             const limit = Math.min(parseInt(String(req.query.limit ?? 50), 10), 500);
             const offset = Math.max(parseInt(String(req.query.offset ?? 0), 10), 0);
-            const conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                const records = await (0, dbConnection_1.queryRecordsInternal)(internal.client, internal.dbType, req.params.tableName, limit, offset, req.params.id);
-                return res.status(200).json({ data: records });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            const records = await (0, dbConnection_1.queryRecords)(resolved.connectionString, resolved.conn.dbType, req.params.tableName, limit, offset);
-            return res.status(200).json({ data: records });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                const records = await (0, dbConnection_1.queryRecordsInternal)(resolved.client, resolved.type, req.params.tableName, limit, offset, req.params.id);
+                res.status(200).json({ data: records });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to query records', details: err.message });
@@ -347,25 +230,10 @@ function dbConnectionRouter(config) {
             if (!record || typeof record !== 'object' || Array.isArray(record)) {
                 return res.status(400).json({ message: 'Request body must be a JSON object' });
             }
-            const conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                const inserted = await (0, dbConnection_1.insertRecordInternal)(internal.client, internal.dbType, req.params.tableName, record, req.params.id);
-                return res.status(201).json({ data: inserted });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            const inserted = await (0, dbConnection_1.insertRecord)(resolved.connectionString, resolved.conn.dbType, req.params.tableName, record);
-            return res.status(201).json({ data: inserted });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                const inserted = await (0, dbConnection_1.insertRecordInternal)(resolved.client, resolved.type, req.params.tableName, record, req.params.id);
+                res.status(201).json({ data: inserted });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to insert record', details: err.message });
@@ -386,25 +254,10 @@ function dbConnectionRouter(config) {
             if (!updates || typeof updates !== 'object' || Array.isArray(updates)) {
                 return res.status(400).json({ message: 'Request body must be a JSON object' });
             }
-            const conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                const updated = await (0, dbConnection_1.updateRecordInternal)(internal.client, internal.dbType, req.params.tableName, req.params.recordId, updates, req.params.id);
-                return res.status(200).json({ data: updated });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            const updated = await (0, dbConnection_1.updateRecord)(resolved.connectionString, resolved.conn.dbType, req.params.tableName, req.params.recordId, updates);
-            return res.status(200).json({ data: updated });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                const updated = await (0, dbConnection_1.updateRecordInternal)(resolved.client, resolved.type, req.params.tableName, req.params.recordId, updates, req.params.id);
+                res.status(200).json({ data: updated });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to update record', details: err.message });
@@ -421,25 +274,10 @@ 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' });
-            const conn = findDbConnection(project, req.params.connId);
-            if (!conn)
-                return res.status(404).json({ message: 'DB connection not found' });
-            if (conn.source === 'builtin') {
-                const builtinId = conn.integrationId;
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'database'))) {
-                    return res.status(403).json({ message: 'Access to this built-in database is not permitted' });
-                }
-                const internal = resolveBuiltinConnection(builtinId, config);
-                if ('error' in internal)
-                    return res.status(internal.status).json({ message: internal.error });
-                await (0, dbConnection_1.deleteRecordInternal)(internal.client, internal.dbType, req.params.tableName, req.params.recordId, req.params.id);
-                return res.status(200).json({ message: 'Record deleted' });
-            }
-            const resolved = await getDecryptedConnectionString(project, req.params.connId);
-            if ('error' in resolved)
-                return res.status(resolved.status).json({ message: resolved.error });
-            await (0, dbConnection_1.deleteRecord)(resolved.connectionString, resolved.conn.dbType, req.params.tableName, req.params.recordId);
-            return res.status(200).json({ message: 'Record deleted' });
+            await withResolvedDbClient(project, req.params.connId, config, auth, res, async (resolved) => {
+                await (0, dbConnection_1.deleteRecordInternal)(resolved.client, resolved.type, req.params.tableName, req.params.recordId, req.params.id);
+                res.status(200).json({ message: 'Record deleted' });
+            });
         }
         catch (err) {
             res.status(500).json({ message: 'Failed to delete record', 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) {

package/dist/middleware/routes/renderFarm.js

@@ -9,6 +9,7 @@ const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const jobQueue_1 = require("../../services/jobQueue");
 const vfxProcessor_1 = require("../../services/vfxProcessor");
+const sanitize_1 = require("../../utils/sanitize");
 const crypto_1 = __importDefault(require("crypto"));
 function renderFarmRouter(_config) {
     const router = (0, express_1.Router)();
@@ -23,7 +24,7 @@ function renderFarmRouter(_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.renderFarmConnections ?? [] });
+            res.json({ connections: (0, sanitize_1.sanitizeConnections)(project.renderFarmConnections) });
         }
         catch (err) {
             res.status(500).json({ message: err.message });
@@ -33,7 +34,7 @@ function renderFarmRouter(_config) {
         try {
             const auth = req.auth;
             const { projectId } = req.params;
-            const { name, provider, apiUrl, credentialId, description } = req.body;
+            const { name, provider, apiUrl, encryptedCredential, description } = req.body;
             if (!name || !provider || !apiUrl) {
                 return res.status(400).json({ message: 'name, provider and apiUrl are required' });
             }
@@ -47,13 +48,13 @@ function renderFarmRouter(_config) {
                 name,
                 provider,
                 apiUrl,
-                credentialId,
+                encryptedCredential,
                 description,
                 projectId,
                 createdAt: new Date(),
             };
             await Project.update({ _id: projectId }, { $push: { renderFarmConnections: 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/storage.js

@@ -8,13 +8,11 @@ const express_1 = require("express");
 const file_1 = require("../../services/file");
 const presign_1 = require("../../services/presign");
 const storage_1 = require("../../providers/storage");
-const s3_1 = require("../../adapters/storage/s3");
 const manager_1 = require("../../models/manager");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
 const auth_1 = require("../../utils/auth");
-const encryption_1 = require("../../utils/encryption");
 const builtinAccess_1 = require("../../utils/builtinAccess");
-const userIntegration_1 = require("../../services/userIntegration");
+const connectionResolver_1 = require("../../services/connectionResolver");
 const mongodb_1 = require("mongodb");
 const crypto_1 = __importDefault(require("crypto"));
 const VALID_CATEGORIES = ['images', 'audios', 'videos', '3d-models'];
@@ -69,46 +67,7 @@ function storageRouter(config) {
             : { storageConnectionId: connId };
         return { projectId, ...connMatch, ...(extra ?? {}) };
     }
-    async function resolveConnAdapter(connId, project, auth) {
-        const conn = findStorageConn(project, connId);
-        if (!conn)
-            return { error: 'Storage connection not found', status: 404 };
-        if (conn.source === 'builtin') {
-            const builtinId = conn.integrationId;
-            if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, builtinId, config, 'storage'))) {
-                return { error: 'Access to this built-in storage is not permitted', status: 403 };
-            }
-            const provider = config.storageProviders.find(p => p.id === builtinId);
-            if (!provider)
-                return { error: 'Storage provider not found', status: 404 };
-            return provider.type === 's3' ? new s3_1.S3Adapter(provider.config) : adapter;
-        }
-        if (conn.source === 'integration') {
-            if (!conn.integrationId)
-                return { error: 'Connection is missing its integrationId', status: 500 };
-            try {
-                const s3Config = await (0, userIntegration_1.getDecryptedIntegrationCredentialById)(conn.integrationId);
-                if (!s3Config)
-                    return { error: 'Integration not found', status: 400 };
-                return new s3_1.S3Adapter(s3Config);
-            }
-            catch (e) {
-                return { error: `Failed to initialize storage adapter: ${e.message}`, status: 500 };
-            }
-        }
-        if (!(0, encryption_1.isEncryptionKeySet)())
-            return { error: 'Encryption key 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 };
-        try {
-            const s3Config = JSON.parse((0, encryption_1.decrypt)(credential.encryptedValue));
-            return new s3_1.S3Adapter(s3Config);
-        }
-        catch (e) {
-            return { error: `Failed to initialize storage adapter: ${e.message}`, status: 500 };
-        }
-    }
+    const resolveConnAdapter = (connId, project, auth) => (0, connectionResolver_1.resolveStorageAdapter)(project, connId, { ...config, adapter }, auth);
     router.get('/upload-project-image-url/:id', async (req, res) => {
         try {
             const auth = req.auth;