streamby-core 0.29.9 → 0.29.12

package/dist/adapters/database/connectionManager.js

@@ -81,6 +81,7 @@ const ensureTablesExist = async (pool) => {
       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(`

package/dist/middleware/routes/dbConnection.js

@@ -40,24 +40,41 @@ 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 dbConnection_1 = require("../../services/dbConnection");
 const VALID_DB_TYPES = ['postgresql', 'mongodb'];
-function resolveBuiltinConnection(connId, config) {
-    const db = (config.databases ?? []).find(d => d.id === connId);
+// `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 '${connId}' not found in config`, status: 404 };
+        return { error: `Database '${builtinId}' not found in config`, status: 404 };
     try {
-        const { client, type } = (0, connectionManager_1.getConnection)(connId);
+        const { client, type } = (0, connectionManager_1.getConnection)(builtinId);
         return { client: client, dbType: type };
     }
     catch (e) {
         return { error: e.message, status: 503 };
     }
 }
+// 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 };
+    }
     const { decrypt, isEncryptionKeySet } = await Promise.resolve().then(() => __importStar(require('../../utils/encryption')));
     if (!isEncryptionKeySet())
         return { error: 'Encryption key is not set', status: 500 };
@@ -91,9 +108,15 @@ function dbConnectionRouter(config) {
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ message: 'Permission denied' });
             }
-            const { name, dbType, credentialId, description } = req.body;
-            if (!name || !dbType || !credentialId) {
-                return res.status(400).json({ message: 'name, dbType, and credentialId are required' });
+            const { name, dbType, credentialId, 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 (credentialId && integrationId) {
+                return res.status(400).json({ message: 'Provide only one of credentialId or integrationId' });
             }
             if (!VALID_DB_TYPES.includes(dbType)) {
                 return res.status(400).json({ message: `dbType must be one of: ${VALID_DB_TYPES.join(', ')}` });
@@ -103,16 +126,28 @@ 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 credExists = project.credentials?.some((c) => c.id === credentialId);
-            if (!credExists)
-                return res.status(400).json({ message: 'Credential not found in project' });
+            if (integrationId) {
+                const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
+                const integration = await UserIntegrationModel.findOne({ id: integrationId, userId: auth.userId });
+                if (!integration)
+                    return res.status(404).json({ message: 'Integration not found' });
+                if (integration.kind !== 'database')
+                    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' });
+            }
             const connection = {
                 id: new mongodb_1.ObjectId().toHexString(),
                 name,
                 dbType,
-                credentialId,
+                credentialId: credentialId ?? '',
                 projectId: req.params.id,
                 createdAt: new Date(),
+                source: integrationId ? 'integration' : 'manual',
+                ...(integrationId && { integrationId }),
                 ...(description !== undefined && { description }),
             };
             await Project.update({ _id: req.params.id }, { $push: { dbConnections: connection } });
@@ -125,9 +160,6 @@ function dbConnectionRouter(config) {
     // ─── Delete DB connection ─────────────────────────────────────────────────
     router.delete('/projects/:id/connections/db/:connId', async (req, res) => {
         try {
-            if ((0, builtinAccess_1.isBuiltinDb)(req.params.connId, config)) {
-                return res.status(403).json({ message: 'Cannot delete a built-in database connection' });
-            }
             const auth = req.auth;
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ message: 'Permission denied' });
@@ -137,9 +169,12 @@ 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 exists = project.dbConnections?.some((c) => c.id === req.params.connId);
-            if (!exists)
+            const conn = findDbConnection(project, req.params.connId);
+            if (!conn)
                 return res.status(404).json({ message: 'DB connection not found' });
+            if (conn.source === 'builtin') {
+                return res.status(403).json({ message: 'Cannot delete a built-in database connection' });
+            }
             await Project.update({ _id: req.params.id }, { $pull: { dbConnections: { id: req.params.connId } } });
             return res.status(200).json({ message: 'DB connection deleted successfully' });
         }
@@ -156,11 +191,15 @@ 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' });
-            if ((0, builtinAccess_1.isBuiltinDb)(req.params.connId, config)) {
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, req.params.connId, config, 'database'))) {
+            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(req.params.connId, config);
+                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);
@@ -191,11 +230,15 @@ function dbConnectionRouter(config) {
             const schema = req.body;
             if (!schema.tableName)
                 return res.status(400).json({ message: 'tableName is required' });
-            if ((0, builtinAccess_1.isBuiltinDb)(req.params.connId, config)) {
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, req.params.connId, config, 'database'))) {
+            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(req.params.connId, config);
+                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)) {
@@ -229,11 +272,15 @@ 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' });
-            if ((0, builtinAccess_1.isBuiltinDb)(req.params.connId, config)) {
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, req.params.connId, config, 'database'))) {
+            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(req.params.connId, config);
+                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);
@@ -260,11 +307,15 @@ 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);
-            if ((0, builtinAccess_1.isBuiltinDb)(req.params.connId, config)) {
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, req.params.connId, config, 'database'))) {
+            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(req.params.connId, config);
+                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);
@@ -296,11 +347,15 @@ function dbConnectionRouter(config) {
             if (!record || typeof record !== 'object' || Array.isArray(record)) {
                 return res.status(400).json({ message: 'Request body must be a JSON object' });
             }
-            if ((0, builtinAccess_1.isBuiltinDb)(req.params.connId, config)) {
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, req.params.connId, config, 'database'))) {
+            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(req.params.connId, config);
+                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);
@@ -331,11 +386,15 @@ function dbConnectionRouter(config) {
             if (!updates || typeof updates !== 'object' || Array.isArray(updates)) {
                 return res.status(400).json({ message: 'Request body must be a JSON object' });
             }
-            if ((0, builtinAccess_1.isBuiltinDb)(req.params.connId, config)) {
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, req.params.connId, config, 'database'))) {
+            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(req.params.connId, config);
+                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);
@@ -362,11 +421,15 @@ 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' });
-            if ((0, builtinAccess_1.isBuiltinDb)(req.params.connId, config)) {
-                if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, req.params.connId, config, 'database'))) {
+            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(req.params.connId, config);
+                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);

package/dist/middleware/routes/project.js

@@ -1,17 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectRouter = projectRouter;
 const express_1 = require("express");
-const crypto_1 = __importDefault(require("crypto"));
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const connectionManager_1 = require("../../adapters/database/connectionManager");
 const sql_1 = require("../../adapters/database/sql");
 const sanitize_1 = require("../../utils/sanitize");
-const builtinAccess_1 = require("../../utils/builtinAccess");
+const projectIntegration_1 = require("../../services/projectIntegration");
 function projectRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
@@ -98,47 +94,14 @@ function projectRouter(config) {
             const dbConnections = [];
             const storageConnections = [];
             if (Array.isArray(integrationIds)) {
-                const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
                 for (const id of integrationIds) {
-                    const now = new Date();
-                    if ((0, builtinAccess_1.isBuiltinDb)(id, config)) {
-                        if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, id, config, 'database'))) {
-                            return res.status(403).json({ message: `Access to built-in database '${id}' is not permitted` });
-                        }
-                        const db = config.databases.find(d => d.id === id);
-                        dbConnections.push({
-                            id: crypto_1.default.randomUUID(), name: id, dbType: db.type === 'sql' ? 'postgresql' : 'mongodb',
-                            credentialId: '', projectId: '', createdAt: now, isBuiltin: true, integrationId: id, source: 'builtin',
-                        });
-                    }
-                    else if ((0, builtinAccess_1.isBuiltinStorageId)(id, config)) {
-                        if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, id, config, 'storage'))) {
-                            return res.status(403).json({ message: `Access to built-in storage '${id}' is not permitted` });
-                        }
-                        const provider = config.storageProviders.find(p => p.id === id);
-                        storageConnections.push({
-                            id: crypto_1.default.randomUUID(), name: id, type: provider.type,
-                            credentialId: '', projectId: '', createdAt: now, isBuiltin: true, integrationId: id, source: 'builtin',
-                        });
-                    }
-                    else {
-                        const integration = await UserIntegrationModel.findOne({ id, userId: auth.userId });
-                        if (!integration) {
-                            return res.status(403).json({ message: `Integration '${id}' is not valid or does not belong to you` });
-                        }
-                        if (integration.kind === 'database') {
-                            dbConnections.push({
-                                id: crypto_1.default.randomUUID(), name: integration.name, dbType: integration.provider,
-                                credentialId: '', projectId: '', createdAt: now, isBuiltin: false, integrationId: id, source: 'integration',
-                            });
-                        }
-                        else {
-                            storageConnections.push({
-                                id: crypto_1.default.randomUUID(), name: integration.name, type: integration.provider,
-                                credentialId: '', projectId: '', createdAt: now, isBuiltin: false, integrationId: id, source: 'integration',
-                            });
-                        }
-                    }
+                    const result = await (0, projectIntegration_1.classifyIntegrationId)(id, auth, config, '');
+                    if ('error' in result)
+                        return res.status(result.status).json({ message: result.error });
+                    if (result.kind === 'database')
+                        dbConnections.push(result.connection);
+                    else
+                        storageConnections.push(result.connection);
                 }
             }
             let newProject = await Project.create({
@@ -430,5 +393,68 @@ function projectRouter(config) {
             res.status(500).json({ message: 'Failed to update project origins', details: err.message });
         }
     });
+    // ─── Add an integration to an existing project ───────────────────────────
+    router.post('/projects/:id/integrations', 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 { integrationId } = req.body;
+            if (!integrationId)
+                return res.status(400).json({ message: 'integrationId is required' });
+            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' });
+            const alreadyConnected = [...(project.dbConnections ?? []), ...(project.storageConnections ?? [])]
+                .some((c) => c.integrationId === integrationId);
+            if (alreadyConnected)
+                return res.status(400).json({ message: 'This integration is already connected to the project' });
+            const result = await (0, projectIntegration_1.classifyIntegrationId)(integrationId, auth, config, projectId);
+            if ('error' in result)
+                return res.status(result.status).json({ message: result.error });
+            const updated = result.kind === 'database'
+                ? await Project.update({ _id: projectId }, { $push: { dbConnections: result.connection } })
+                : await Project.update({ _id: projectId }, { $push: { storageConnections: result.connection } });
+            if (!updated)
+                return res.status(404).json({ message: 'Project not found or not updated' });
+            res.status(201).json({ data: result.connection, project: (0, sanitize_1.sanitizeProject)(updated) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to add integration', details: err.message });
+        }
+    });
+    // ─── Remove an integration from a project ────────────────────────────────
+    router.delete('/projects/:id/integrations/:integrationId', 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 { integrationId } = req.params;
+            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' });
+            const dbConn = (project.dbConnections ?? []).find((c) => c.integrationId === integrationId);
+            const storageConn = (project.storageConnections ?? []).find((c) => c.integrationId === integrationId);
+            if (!dbConn && !storageConn)
+                return res.status(404).json({ message: 'Integration not connected to this project' });
+            const updated = dbConn
+                ? await Project.update({ _id: projectId }, { $pull: { dbConnections: { id: dbConn.id } } })
+                : await Project.update({ _id: projectId }, { $pull: { storageConnections: { id: storageConn.id } } });
+            if (!updated)
+                return res.status(404).json({ message: 'Project not found or not updated' });
+            res.status(200).json({ message: 'Integration removed', project: (0, sanitize_1.sanitizeProject)(updated) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to remove integration', details: err.message });
+        }
+    });
     return router;
 }

package/dist/middleware/routes/storage.js

@@ -14,6 +14,7 @@ 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 mongodb_1 = require("mongodb");
 const crypto_1 = __importDefault(require("crypto"));
 const VALID_CATEGORIES = ['images', 'audios', 'videos', '3d-models'];
@@ -51,26 +52,50 @@ function storageRouter(config) {
     const router = (0, express_1.Router)();
     const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
     const Project = (0, manager_1.getModel)('projects');
-    function connFilter(projectId, connId, extra) {
-        const isBuiltin = (0, builtinAccess_1.isBuiltinStorageId)(connId, config);
+    // A row is builtin iff its own `source === 'builtin'` (set at backfill/creation time) —
+    // NOT by comparing connId (the row's own generated id) against config.storageProviders,
+    // which no longer holds since builtin rows get their own id distinct from provider.id.
+    function findStorageConn(project, connId) {
+        return project.storageConnections?.find((c) => c.id === connId);
+    }
+    function connFilter(projectId, connId, project, extra) {
+        const conn = findStorageConn(project, connId);
+        const isBuiltin = conn?.source === 'builtin';
+        // Builtin files may be stamped one of two ways depending on when they were uploaded:
+        // legacy docs (pre-per-row-ids) used the builtin's config id (e.g. 'builtin') or have no
+        // storageConnectionId at all; current uploads use the row's own generated id (connId).
         const connMatch = isBuiltin
-            ? { $or: [{ storageConnectionId: connId }, { storageConnectionId: { $exists: false } }] }
+            ? { $or: [{ storageConnectionId: connId }, { storageConnectionId: conn.integrationId }, { storageConnectionId: { $exists: false } }] }
             : { storageConnectionId: connId };
         return { projectId, ...connMatch, ...(extra ?? {}) };
     }
     async function resolveConnAdapter(connId, project, auth) {
-        if ((0, builtinAccess_1.isBuiltinStorageId)(connId, config)) {
-            if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, connId, config, 'storage'))) {
+        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 === connId);
+            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;
         }
-        const conn = project.storageConnections?.find((c) => c.id === connId);
-        if (!conn)
-            return { error: 'Storage connection not found', status: 404 };
+        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);
@@ -354,7 +379,7 @@ function storageRouter(config) {
             const collection = getRawFilesCollection();
             if (!collection)
                 return res.status(500).json({ message: 'Database not available' });
-            const files = await collection.find(connFilter(projectId, connId)).sort({ createdAt: -1 }).limit(12).toArray();
+            const files = await collection.find(connFilter(projectId, connId, project)).sort({ createdAt: -1 }).limit(12).toArray();
             const data = await Promise.all(files.map(f => resolveFileUrl(f, connAdapter)));
             res.json({ data });
         }
@@ -380,7 +405,7 @@ function storageRouter(config) {
             const collection = getRawFilesCollection();
             if (!collection)
                 return res.status(500).json({ message: 'Database not available' });
-            const files = await collection.find(connFilter(projectId, connId, { category })).sort({ createdAt: -1 }).toArray();
+            const files = await collection.find(connFilter(projectId, connId, project, { category })).sort({ createdAt: -1 }).toArray();
             const data = await Promise.all(files.map(f => resolveFileUrl(f, connAdapter)));
             res.json({ data });
         }
@@ -404,7 +429,7 @@ function storageRouter(config) {
             const collection = getRawFilesCollection();
             if (!collection)
                 return res.status(500).json({ message: 'Database not available' });
-            const fileDoc = await collection.findOne(connFilter(projectId, connId, { fileId }));
+            const fileDoc = await collection.findOne(connFilter(projectId, connId, project, { fileId }));
             if (!fileDoc)
                 return res.status(404).json({ message: 'File not found' });
             if (!validateContentType(contentType, fileName, fileDoc.category)) {
@@ -417,7 +442,7 @@ function storageRouter(config) {
                 return res.status(501).json({ message: 'Storage adapter does not support presigned uploads' });
             }
             const url = await connAdapter.getPresignedUploadUrl(fileDoc.storageKey, contentType);
-            await collection.updateOne(connFilter(projectId, connId, { fileId }), { $set: { contentType, updatedAt: new Date() } });
+            await collection.updateOne(connFilter(projectId, connId, project, { fileId }), { $set: { contentType, updatedAt: new Date() } });
             res.json({ url, storageKey: fileDoc.storageKey, fileId });
         }
         catch (err) {
@@ -440,7 +465,7 @@ function storageRouter(config) {
             const collection = getRawFilesCollection();
             if (!collection)
                 return res.status(500).json({ message: 'Database not available' });
-            const result = await collection.findOneAndUpdate(connFilter(projectId, connId, { fileId }), { $set: { displayName } }, { returnDocument: 'after' });
+            const result = await collection.findOneAndUpdate(connFilter(projectId, connId, project, { fileId }), { $set: { displayName } }, { returnDocument: 'after' });
             if (!result)
                 return res.status(404).json({ message: 'File not found' });
             res.json({ message: 'File renamed successfully', file: result });
@@ -464,12 +489,12 @@ function storageRouter(config) {
             const collection = getRawFilesCollection();
             if (!collection)
                 return res.status(500).json({ message: 'Database not available' });
-            const fileDoc = await collection.findOne(connFilter(projectId, connId, { fileId }));
+            const fileDoc = await collection.findOne(connFilter(projectId, connId, project, { fileId }));
             if (!fileDoc)
                 return res.status(404).json({ message: 'File not found' });
             if (connAdapter.deleteFile)
                 await connAdapter.deleteFile(fileDoc.storageKey);
-            await collection.deleteOne(connFilter(projectId, connId, { fileId }));
+            await collection.deleteOne(connFilter(projectId, connId, project, { fileId }));
             res.json({ message: 'File deleted successfully' });
         }
         catch (err) {
@@ -494,7 +519,7 @@ function storageRouter(config) {
                 ? { parentId: null }
                 : { parentId };
             const folders = await collection
-                .find(connFilter(projectId, connId, parentFilter))
+                .find(connFilter(projectId, connId, project, parentFilter))
                 .sort({ name: 1 })
                 .toArray();
             res.json({
@@ -525,7 +550,7 @@ function storageRouter(config) {
             const collection = getRawFoldersCollection();
             if (!collection)
                 return res.status(500).json({ message: 'Database not available' });
-            const f = await collection.findOne(connFilter(projectId, connId, { folderId }));
+            const f = await collection.findOne(connFilter(projectId, connId, project, { folderId }));
             if (!f)
                 return res.status(404).json({ message: 'Folder not found' });
             res.json({
@@ -557,8 +582,9 @@ function storageRouter(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 access' });
-            const isBuiltin = (0, builtinAccess_1.isBuiltinStorageId)(connId, config);
-            if (isBuiltin && !(await (0, builtinAccess_1.assertBuiltinAccess)(auth, connId, config, 'storage'))) {
+            const conn = findStorageConn(project, connId);
+            const isBuiltin = conn?.source === 'builtin';
+            if (isBuiltin && !(await (0, builtinAccess_1.assertBuiltinAccess)(auth, conn.integrationId, config, 'storage'))) {
                 return res.status(403).json({ message: 'Access to this built-in storage is not permitted' });
             }
             const collection = getRawFoldersCollection();
@@ -610,7 +636,7 @@ function storageRouter(config) {
             const collection = getRawFoldersCollection();
             if (!collection)
                 return res.status(500).json({ message: 'Database not available' });
-            const result = await collection.findOneAndUpdate(connFilter(projectId, connId, { folderId }), { $set: { name: name.trim(), updatedAt: new Date() } }, { returnDocument: 'after' });
+            const result = await collection.findOneAndUpdate(connFilter(projectId, connId, project, { folderId }), { $set: { name: name.trim(), updatedAt: new Date() } }, { returnDocument: 'after' });
             if (!result)
                 return res.status(404).json({ message: 'Folder not found' });
             res.json({
@@ -644,7 +670,7 @@ function storageRouter(config) {
             const collection = getRawFoldersCollection();
             if (!collection)
                 return res.status(500).json({ message: 'Database not available' });
-            const result = await collection.findOneAndUpdate(connFilter(projectId, connId, { folderId }), { $set: { parentId: newParentId ?? null, updatedAt: new Date() } }, { returnDocument: 'after' });
+            const result = await collection.findOneAndUpdate(connFilter(projectId, connId, project, { folderId }), { $set: { parentId: newParentId ?? null, updatedAt: new Date() } }, { returnDocument: 'after' });
             if (!result)
                 return res.status(404).json({ message: 'Folder not found' });
             res.json({
@@ -674,15 +700,15 @@ function storageRouter(config) {
             const foldersCollection = getRawFoldersCollection();
             if (!foldersCollection)
                 return res.status(500).json({ message: 'Database not available' });
-            const folderDoc = await foldersCollection.findOne(connFilter(projectId, connId, { folderId }));
+            const folderDoc = await foldersCollection.findOne(connFilter(projectId, connId, project, { folderId }));
             if (!folderDoc)
                 return res.status(404).json({ message: 'Folder not found' });
             const filesCollection = getRawFilesCollection();
             if (filesCollection) {
-                await filesCollection.updateMany(connFilter(projectId, connId, { folderId }), { $set: { folderId: folderDoc.parentId ?? null } });
+                await filesCollection.updateMany(connFilter(projectId, connId, project, { folderId }), { $set: { folderId: folderDoc.parentId ?? null } });
             }
-            await foldersCollection.updateMany(connFilter(projectId, connId, { parentId: folderId }), { $set: { parentId: folderDoc.parentId ?? null } });
-            await foldersCollection.deleteOne(connFilter(projectId, connId, { folderId }));
+            await foldersCollection.updateMany(connFilter(projectId, connId, project, { parentId: folderId }), { $set: { parentId: folderDoc.parentId ?? null } });
+            await foldersCollection.deleteOne(connFilter(projectId, connId, project, { folderId }));
             res.json({ message: 'Folder deleted successfully' });
         }
         catch (err) {
@@ -702,7 +728,7 @@ function storageRouter(config) {
             if (folderId != null) {
                 const foldersCollection = getRawFoldersCollection();
                 if (foldersCollection) {
-                    const folderDoc = await foldersCollection.findOne(connFilter(projectId, connId, { folderId }));
+                    const folderDoc = await foldersCollection.findOne(connFilter(projectId, connId, project, { folderId }));
                     if (!folderDoc)
                         return res.status(404).json({ message: 'Folder not found' });
                 }
@@ -710,7 +736,7 @@ function storageRouter(config) {
             const filesCollection = getRawFilesCollection();
             if (!filesCollection)
                 return res.status(500).json({ message: 'Database not available' });
-            const result = await filesCollection.findOneAndUpdate(connFilter(projectId, connId, { fileId }), { $set: { folderId: folderId ?? null } }, { returnDocument: 'after' });
+            const result = await filesCollection.findOneAndUpdate(connFilter(projectId, connId, project, { fileId }), { $set: { folderId: folderId ?? null } }, { returnDocument: 'after' });
             if (!result)
                 return res.status(404).json({ message: 'File not found' });
             res.json({ message: 'File moved successfully', file: result });

package/dist/middleware/routes/storageConnection.js

@@ -41,9 +41,15 @@ function storageConnectionRouter(config) {
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ message: 'Permission denied' });
             }
-            const { name, type, credentialId, description } = req.body;
-            if (!name || !type || !credentialId) {
-                return res.status(400).json({ message: 'name, type, and credentialId are required' });
+            const { name, type, credentialId, integrationId, description } = req.body;
+            if (!name || !type) {
+                return res.status(400).json({ message: 'name and type are required' });
+            }
+            if (!credentialId && !integrationId) {
+                return res.status(400).json({ message: 'Either credentialId or integrationId is required' });
+            }
+            if (credentialId && integrationId) {
+                return res.status(400).json({ message: 'Provide only one of credentialId or integrationId' });
             }
             if (!VALID_STORAGE_TYPES.includes(type)) {
                 return res.status(400).json({ message: `type must be one of: ${VALID_STORAGE_TYPES.join(', ')}` });
@@ -53,16 +59,28 @@ function storageConnectionRouter(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 credExists = project.credentials?.some((c) => c.id === credentialId);
-            if (!credExists)
-                return res.status(400).json({ message: 'Credential not found in project' });
+            if (integrationId) {
+                const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
+                const integration = await UserIntegrationModel.findOne({ id: integrationId, userId: auth.userId });
+                if (!integration)
+                    return res.status(404).json({ message: 'Integration not found' });
+                if (integration.kind !== 'storage')
+                    return res.status(400).json({ message: 'Integration is not a storage integration' });
+            }
+            else {
+                const credExists = project.credentials?.some((c) => c.id === credentialId);
+                if (!credExists)
+                    return res.status(400).json({ message: 'Credential not found in project' });
+            }
             const connection = {
                 id: new mongodb_1.ObjectId().toHexString(),
                 name,
                 type,
-                credentialId,
+                credentialId: credentialId ?? '',
                 projectId: req.params.id,
                 createdAt: new Date(),
+                source: integrationId ? 'integration' : 'manual',
+                ...(integrationId && { integrationId }),
                 ...(description !== undefined && { description }),
             };
             await Project.update({ _id: req.params.id }, { $push: { storageConnections: connection } });
@@ -76,9 +94,6 @@ function storageConnectionRouter(config) {
     router.delete('/projects/:id/connections/storage/:connId', async (req, res) => {
         try {
             const { connId } = req.params;
-            if ((0, builtinAccess_1.isBuiltinStorageId)(connId, config)) {
-                return res.status(403).json({ message: 'Cannot delete a built-in storage connection' });
-            }
             const auth = req.auth;
             if (auth.role !== 'admin' && auth.role !== 'editor') {
                 return res.status(403).json({ message: 'Permission denied' });
@@ -88,9 +103,12 @@ function storageConnectionRouter(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 exists = project.storageConnections?.some((c) => c.id === connId);
-            if (!exists)
+            const conn = project.storageConnections?.find((c) => c.id === connId);
+            if (!conn)
                 return res.status(404).json({ message: 'Storage connection not found' });
+            if (conn.source === 'builtin') {
+                return res.status(403).json({ message: 'Cannot delete a built-in storage connection' });
+            }
             await Project.update({ _id: req.params.id }, { $pull: { storageConnections: { id: connId } } });
             return res.status(200).json({ message: 'Storage connection deleted successfully' });
         }

package/dist/middleware/routes/userIntegration.js

@@ -22,11 +22,11 @@ function userIntegrationRouter(config) {
                 // requiredPlan is not populated here — canUseBuiltin only returns a boolean today,
                 // so there's no plan-level detail to surface without a hook-signature change.
                 const available = await (0, builtinAccess_1.assertBuiltinAccess)(auth, db.id, config, 'database');
-                pool.push({ id: db.id, kind: 'database', name: db.id, provider: db.type, source: 'builtin', available });
+                pool.push({ id: db.id, kind: 'database', name: builtinAccess_1.BUILTIN_DB_DISPLAY[db.type] ?? db.type, provider: db.type, source: 'builtin', available });
             }
             for (const provider of config.storageProviders ?? []) {
                 const available = await (0, builtinAccess_1.assertBuiltinAccess)(auth, provider.id, config, 'storage');
-                pool.push({ id: provider.id, kind: 'storage', name: provider.id, provider: provider.type, source: 'builtin', available });
+                pool.push({ id: provider.id, kind: 'storage', name: builtinAccess_1.BUILTIN_STORAGE_DISPLAY[provider.type] ?? provider.type, provider: provider.type, source: 'builtin', available });
             }
             res.json({ data: pool });
         }

package/dist/services/backfillBuiltinConnections.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.backfillBuiltinConnections = backfillBuiltinConnections;
 const crypto_1 = __importDefault(require("crypto"));
 const manager_1 = require("../models/manager");
+const builtinAccess_1 = require("../utils/builtinAccess");
 // Pre-BYOC, every project appeared connected to every configured builtin because
 // storageConnection.ts/dbConnection.ts SYNTHESIZED builtins at read time instead of
 // persisting them (see storageConnection.ts's old GET handler). Now that connections must
@@ -26,7 +27,7 @@ async function backfillBuiltinConnections(config) {
         const now = new Date();
         const dbConnections = (config.databases ?? []).map(db => ({
             id: crypto_1.default.randomUUID(),
-            name: db.id,
+            name: builtinAccess_1.BUILTIN_DB_DISPLAY[db.type] ?? db.type,
             dbType: db.type === 'sql' ? 'postgresql' : 'mongodb',
             credentialId: '',
             projectId: project.id,
@@ -37,7 +38,7 @@ async function backfillBuiltinConnections(config) {
         }));
         const storageConnections = (config.storageProviders ?? []).map(provider => ({
             id: crypto_1.default.randomUUID(),
-            name: provider.id,
+            name: builtinAccess_1.BUILTIN_STORAGE_DISPLAY[provider.type] ?? provider.type,
             type: provider.type,
             credentialId: '',
             projectId: project.id,

package/dist/services/projectIntegration.d.ts

@@ -0,0 +1,13 @@
+import { Auth, DbConnection, StorageConnection, StreamByConfig } from '../types';
+type ClassifyResult = {
+    kind: 'database';
+    connection: DbConnection;
+} | {
+    kind: 'storage';
+    connection: StorageConnection;
+} | {
+    error: string;
+    status: number;
+};
+export declare function classifyIntegrationId(id: string, auth: Auth, config: StreamByConfig, projectId: string): Promise<ClassifyResult>;
+export {};

package/dist/services/projectIntegration.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyIntegrationId = classifyIntegrationId;
+const crypto_1 = __importDefault(require("crypto"));
+const manager_1 = require("../models/manager");
+const builtinAccess_1 = require("../utils/builtinAccess");
+// Classifies a client-supplied integrationId (builtin db, builtin storage, or a user's own
+// BYOC integration) and revalidates access/ownership server-side — never trust the client.
+// Shared by POST /projects/create (bulk, at project creation) and
+// POST /projects/:id/integrations (single, added to an existing project).
+async function classifyIntegrationId(id, auth, config, projectId) {
+    const now = new Date();
+    if ((0, builtinAccess_1.isBuiltinDb)(id, config)) {
+        if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, id, config, 'database'))) {
+            return { error: `Access to built-in database '${id}' is not permitted`, status: 403 };
+        }
+        const db = config.databases.find(d => d.id === id);
+        return {
+            kind: 'database',
+            connection: {
+                id: crypto_1.default.randomUUID(), name: builtinAccess_1.BUILTIN_DB_DISPLAY[db.type] ?? db.type, dbType: db.type === 'sql' ? 'postgresql' : 'mongodb',
+                credentialId: '', projectId, createdAt: now, isBuiltin: true, integrationId: id, source: 'builtin',
+            },
+        };
+    }
+    if ((0, builtinAccess_1.isBuiltinStorageId)(id, config)) {
+        if (!(await (0, builtinAccess_1.assertBuiltinAccess)(auth, id, config, 'storage'))) {
+            return { error: `Access to built-in storage '${id}' is not permitted`, status: 403 };
+        }
+        const provider = config.storageProviders.find(p => p.id === id);
+        return {
+            kind: 'storage',
+            connection: {
+                id: crypto_1.default.randomUUID(), name: builtinAccess_1.BUILTIN_STORAGE_DISPLAY[provider.type] ?? provider.type, type: provider.type,
+                credentialId: '', projectId, createdAt: now, isBuiltin: true, integrationId: id, source: 'builtin',
+            },
+        };
+    }
+    const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
+    const integration = await UserIntegrationModel.findOne({ id, userId: auth.userId });
+    if (!integration) {
+        return { error: `Integration '${id}' is not valid or does not belong to you`, status: 403 };
+    }
+    if (integration.kind === 'database') {
+        return {
+            kind: 'database',
+            connection: {
+                id: crypto_1.default.randomUUID(), name: integration.name, dbType: integration.provider,
+                credentialId: '', projectId, createdAt: now, isBuiltin: false, integrationId: id, source: 'integration',
+            },
+        };
+    }
+    return {
+        kind: 'storage',
+        connection: {
+            id: crypto_1.default.randomUUID(), name: integration.name, type: integration.provider,
+            credentialId: '', projectId, createdAt: now, isBuiltin: false, integrationId: id, source: 'integration',
+        },
+    };
+}

package/dist/services/userIntegration.d.ts

@@ -14,3 +14,4 @@ export declare function updateUserIntegration(userId: string, integrationId: str
 }): Promise<UserIntegration | null>;
 export declare function deleteUserIntegration(userId: string, integrationId: string): Promise<boolean>;
 export declare function getDecryptedIntegrationCredential(userId: string, integrationId: string): Promise<unknown | null>;
+export declare function getDecryptedIntegrationCredentialById(integrationId: string): Promise<unknown | null>;

package/dist/services/userIntegration.js

@@ -8,6 +8,7 @@ exports.createUserIntegration = createUserIntegration;
 exports.updateUserIntegration = updateUserIntegration;
 exports.deleteUserIntegration = deleteUserIntegration;
 exports.getDecryptedIntegrationCredential = getDecryptedIntegrationCredential;
+exports.getDecryptedIntegrationCredentialById = getDecryptedIntegrationCredentialById;
 const crypto_1 = __importDefault(require("crypto"));
 const manager_1 = require("../models/manager");
 const encryption_1 = require("../utils/encryption");
@@ -63,6 +64,18 @@ async function deleteUserIntegration(userId, integrationId) {
 async function getDecryptedIntegrationCredential(userId, integrationId) {
     const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
     const integration = await UserIntegrationModel.findOne({ id: integrationId, userId });
+    return decryptIntegration(integration);
+}
+// Used when resolving a project connection's `integrationId` at connection-use time — the
+// project already validated ownership when the connection was created (see project.ts /
+// dbConnection.ts POST), so there's no userId to filter by here, only the integrationId
+// stored on the connection itself.
+async function getDecryptedIntegrationCredentialById(integrationId) {
+    const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
+    const integration = await UserIntegrationModel.findOne({ id: integrationId });
+    return decryptIntegration(integration);
+}
+async function decryptIntegration(integration) {
     if (!integration)
         return null;
     if (!(0, encryption_1.isEncryptionKeySet)()) {

package/dist/types/index.d.ts

@@ -18,7 +18,7 @@ export interface StorageConnection {
     description?: string;
     isBuiltin?: boolean;
     integrationId?: string;
-    source?: 'builtin' | 'integration';
+    source?: 'builtin' | 'integration' | 'manual';
     available?: boolean;
 }
 export type StorageProvider = {
@@ -159,7 +159,7 @@ export interface DbConnection {
     description?: string;
     isBuiltin?: boolean;
     integrationId?: string;
-    source?: 'builtin' | 'integration';
+    source?: 'builtin' | 'integration' | 'manual';
 }
 export type IntegrationKind = 'database' | 'storage';
 export interface UserIntegration {

package/dist/utils/builtinAccess.d.ts

@@ -2,3 +2,5 @@ import { Auth, StreamByConfig } from '../types';
 export declare function assertBuiltinAccess(auth: Auth, builtinId: string, config: StreamByConfig, kind: 'database' | 'storage'): Promise<boolean>;
 export declare function isBuiltinStorageId(id: string, config: StreamByConfig): boolean;
 export declare function isBuiltinDb(id: string, config: StreamByConfig): boolean;
+export declare const BUILTIN_STORAGE_DISPLAY: Record<string, string>;
+export declare const BUILTIN_DB_DISPLAY: Record<string, string>;

package/dist/utils/builtinAccess.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_DB_DISPLAY = exports.BUILTIN_STORAGE_DISPLAY = void 0;
 exports.assertBuiltinAccess = assertBuiltinAccess;
 exports.isBuiltinStorageId = isBuiltinStorageId;
 exports.isBuiltinDb = isBuiltinDb;
@@ -17,3 +18,15 @@ function isBuiltinStorageId(id, config) {
 function isBuiltinDb(id, config) {
     return (config.databases ?? []).some(db => db.id === id);
 }
+// Display names for builtin connections — never the raw config id/type. The frontend pairs
+// this with the StreamBy icon to visually mark a connection as built-in vs BYOC.
+exports.BUILTIN_STORAGE_DISPLAY = {
+    s3: 'AWS S3',
+    gcs: 'Google Cloud Storage',
+    r2: 'Cloudflare R2',
+    azure: 'Azure Blob Storage',
+};
+exports.BUILTIN_DB_DISPLAY = {
+    sql: 'PostgreSQL',
+    nosql: 'MongoDB',
+};

package/package.json

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