streamby-core 0.27.0 → 0.27.1

package/dist/adapters/database/connectionManager.js

@@ -89,6 +89,7 @@ const ensureTablesExist = async (pool) => {
         "projectId"  TEXT NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
         "userId"     VARCHAR(255) NOT NULL,
         role         VARCHAR(255) NOT NULL DEFAULT 'member',
+        status       VARCHAR(50) NOT NULL DEFAULT 'active',
         archived     BOOLEAN NOT NULL DEFAULT FALSE,
         "archivedBy" VARCHAR(255),
         "archivedAt" TIMESTAMP WITH TIME ZONE,
@@ -96,6 +97,9 @@ const ensureTablesExist = async (pool) => {
         "updatedAt"  TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
         UNIQUE ("projectId", "userId")
       );
+    `);
+        await pool.query(`
+      ALTER TABLE streamby.project_members ADD COLUMN IF NOT EXISTS status VARCHAR(50) NOT NULL DEFAULT 'active';
     `);
         console.log('✅ "project_members" table ensured to exist.');
         // Migrate projectId FK column from UUID to TEXT if table predates this schema version

package/dist/adapters/database/sql.js

@@ -88,7 +88,7 @@ exports.sqlAdapter = {
     delete: async (connection, tableName, filter, schema) => {
         const keys = Object.keys(filter);
         const values = Object.values(filter);
-        const where = keys.map((key, i) => `"${key}" = ${i + 1}`).join(' AND ');
+        const where = keys.map((key, i) => `"${key}" = $${i + 1}`).join(' AND ');
         const fullTableName = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
         const result = await connection.query(`DELETE FROM ${fullTableName} WHERE ${where}`, values);
         return result.rowCount || 0;

package/dist/middleware/createRouter.js

@@ -21,6 +21,7 @@ const database_1 = require("./routes/database");
 const credential_1 = require("./routes/credential");
 const connection_1 = require("./routes/connection");
 const dbConnection_1 = require("./routes/dbConnection");
+const storageConnection_1 = require("./routes/storageConnection");
 const notification_1 = require("./routes/notification");
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
@@ -57,6 +58,7 @@ function createStreamByRouter(config) {
     router.use((0, credential_1.credentialRouter)(config));
     router.use((0, connection_1.connectionRouter)(config));
     router.use((0, dbConnection_1.dbConnectionRouter)(config));
+    router.use((0, storageConnection_1.storageConnectionRouter)(config));
     router.use((0, notification_1.notificationRouter)(config));
     return router;
 }

package/dist/middleware/routes/dbConnection.js

@@ -213,6 +213,35 @@ function dbConnectionRouter(config) {
             res.status(500).json({ message: 'Failed to create table/collection', details: err.message });
         }
     });
+    // ─── Delete table / collection ────────────────────────────────────────────
+    router.delete('/projects/:id/connections/db/:connId/tables/:tableName', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const project = await Project.findOne({ _id: req.params.id });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            if (isBuiltinDb(req.params.connId, config)) {
+                const internal = resolveBuiltinConnection(req.params.connId, 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' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete table/collection', details: err.message });
+        }
+    });
     // ─── Query records ────────────────────────────────────────────────────────
     router.get('/projects/:id/connections/db/:connId/tables/:tableName', async (req, res) => {
         try {
@@ -274,5 +303,65 @@ function dbConnectionRouter(config) {
             res.status(500).json({ message: 'Failed to insert record', details: err.message });
         }
     });
+    // ─── Update record ────────────────────────────────────────────────────────
+    router.put('/projects/:id/connections/db/:connId/tables/:tableName/:recordId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor')
+                return res.status(403).json({ message: 'Permission denied' });
+            const project = await Project.findOne({ _id: req.params.id });
+            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 updates = req.body;
+            if (!updates || typeof updates !== 'object' || Array.isArray(updates)) {
+                return res.status(400).json({ message: 'Request body must be a JSON object' });
+            }
+            if (isBuiltinDb(req.params.connId, config)) {
+                const internal = resolveBuiltinConnection(req.params.connId, 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 });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to update record', details: err.message });
+        }
+    });
+    // ─── Delete record ────────────────────────────────────────────────────────
+    router.delete('/projects/:id/connections/db/:connId/tables/:tableName/:recordId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor')
+                return res.status(403).json({ message: 'Permission denied' });
+            const project = await Project.findOne({ _id: req.params.id });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized project access' });
+            if (isBuiltinDb(req.params.connId, config)) {
+                const internal = resolveBuiltinConnection(req.params.connId, 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' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete record', details: err.message });
+        }
+    });
     return router;
 }

package/dist/middleware/routes/export.js

@@ -168,8 +168,11 @@ function exportRouter(config) {
             let responseData;
             responseData = {
                 ...data,
+                id: exportId,
                 allowedOrigin: exportMetadata.allowedOrigin,
                 private: exportMetadata.private,
+                devMode: exportMetadata.devMode,
+                devPorts: exportMetadata.devPorts,
             };
             res.json({
                 data: responseData,
@@ -215,7 +218,7 @@ function exportRouter(config) {
                 return res.status(401).json({ message: 'Unauthorized' });
             }
             const { id: projectId, export_id: exportId } = req.params;
-            const { name, description, isPrivate, allowedOrigin, useConnections, useCredentials, nodeSchema } = req.body;
+            const { name, description, isPrivate, allowedOrigin, devMode, devPorts, useConnections, useCredentials, nodeSchema } = req.body;
             const project = await Project.findOne({ _id: projectId });
             if (!project || !(0, auth_1.isProjectMember)(project, auth.userId)) {
                 return res.status(403).json({ message: 'Unauthorized project access' });
@@ -228,7 +231,7 @@ function exportRouter(config) {
             const resolvedNodeSchema = nodeSchema ?? exportMetadata.nodeSchema;
             const resolvedUseConnections = useConnections ?? exportMetadata.useConnections;
             const exportType = resolvedUseConnections ? 'externalApi' : 'json';
-            const result = await (0, export_1.updateExport)(config, projectId, exportId, description ?? exportMetadata.description, resolvedName, project.dbType, exportType, isPrivate ?? exportMetadata.private, allowedOrigin ?? exportMetadata.allowedOrigin, resolvedNodeSchema, resolvedUseConnections, useCredentials ?? exportMetadata.useCredentials);
+            const result = await (0, export_1.updateExport)(config, projectId, exportId, description ?? exportMetadata.description, resolvedName, project.dbType, exportType, isPrivate ?? exportMetadata.private, allowedOrigin ?? exportMetadata.allowedOrigin, devMode ?? exportMetadata.devMode, devPorts ?? exportMetadata.devPorts, resolvedNodeSchema, resolvedUseConnections, useCredentials ?? exportMetadata.useCredentials);
             res.status(200).json({ data: result, message: result.message });
         }
         catch (err) {
@@ -284,14 +287,33 @@ function exportRouter(config) {
                     }
                 }
             }
-            // If there's no origin header, deny access unless the effective scope is public.
-            if (!origin && !(effectiveAllowedOrigins && effectiveAllowedOrigins.includes('*'))) {
-                return res.status(403).json({ message: 'Origin header required' });
+            // Dev mode: auto-allow localhost requests on configured ports.
+            let devModeAllowed = false;
+            if (exportMetadata.devMode && origin) {
+                const match = origin.match(/^https?:\/\/localhost:(\d+)$/);
+                if (match) {
+                    const port = parseInt(match[1]);
+                    const allowedPorts = exportMetadata.devPorts?.length
+                        ? exportMetadata.devPorts
+                        : [3000, 5173, 8080, 4200];
+                    if (allowedPorts.includes(port)) {
+                        devModeAllowed = true;
+                        res.header('Access-Control-Allow-Origin', origin);
+                        res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+                        res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+                    }
+                }
             }
-            // Check for public access ('*') or if the request's origin is in the effective list.
-            const isAllowed = effectiveAllowedOrigins && (effectiveAllowedOrigins.includes('*') || (origin && effectiveAllowedOrigins.includes(origin)));
-            if (!isAllowed) {
-                return res.status(403).json({ message: 'Unauthorized' });
+            if (!devModeAllowed) {
+                // If there's no origin header, deny access unless the effective scope is public.
+                if (!origin && !(effectiveAllowedOrigins && effectiveAllowedOrigins.includes('*'))) {
+                    return res.status(403).json({ message: 'Origin header required' });
+                }
+                // Check for public access ('*') or if the request's origin is in the effective list.
+                const isAllowed = effectiveAllowedOrigins && (effectiveAllowedOrigins.includes('*') || (origin && effectiveAllowedOrigins.includes(origin)));
+                if (!isAllowed) {
+                    return res.status(403).json({ message: 'Unauthorized' });
+                }
             }
             let data;
             if (exportMetadata.nodeSchema) {

package/dist/middleware/routes/storage.js

@@ -8,9 +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 mongodb_1 = require("mongodb");
 const crypto_1 = __importDefault(require("crypto"));
 const VALID_CATEGORIES = ['images', 'audios', 'videos', '3d-models'];
@@ -36,6 +38,32 @@ function getRawFilesCollection() {
         return null;
     return (0, connectionManager_1.getConnection)(activeId).client.db().collection('storage_files');
 }
+function connFilter(projectId, connId, extra) {
+    const isBuiltin = connId === 'builtin' || connId.startsWith('builtin-');
+    const connMatch = isBuiltin
+        ? { $or: [{ storageConnectionId: connId }, { storageConnectionId: { $exists: false } }] }
+        : { storageConnectionId: connId };
+    return { projectId, ...connMatch, ...(extra ?? {}) };
+}
+async function resolveConnAdapter(connId, project, globalAdapter) {
+    if (connId === 'builtin' || connId.startsWith('builtin-'))
+        return globalAdapter;
+    const conn = project.storageConnections?.find((c) => c.id === connId);
+    if (!conn)
+        return { error: 'Storage connection not found', status: 404 };
+    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 };
+    }
+}
 function storageRouter(config) {
     const router = (0, express_1.Router)();
     const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
@@ -212,6 +240,157 @@ function storageRouter(config) {
             res.status(500).json({ message: 'Failed to list files', details: err.message });
         }
     });
+    // ─── Per-connection file routes ───────────────────────────────────────────
+    router.get('/projects/:projectId/connections/storage/:connId/upload-url', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId } = req.params;
+            const { fileName, contentType, category } = req.query;
+            if (!category || !VALID_CATEGORIES.includes(category)) {
+                return res.status(400).json({ message: `Invalid category. Must be one of: ${VALID_CATEGORIES.join(', ')}` });
+            }
+            if (!fileName || !contentType) {
+                return res.status(400).json({ message: 'Query params fileName and contentType are required' });
+            }
+            if (!validateContentType(contentType, fileName, category)) {
+                return res.status(400).json({ message: `File does not match category ${category}` });
+            }
+            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 access' });
+            const connAdapter = await resolveConnAdapter(connId, project, adapter);
+            if ('error' in connAdapter)
+                return res.status(connAdapter.status).json({ message: connAdapter.error });
+            if (!connAdapter.getPresignedUploadUrl)
+                return res.status(501).json({ message: 'Storage adapter does not support presigned uploads' });
+            const ext = fileName.includes('.') ? `.${fileName.split('.').pop().toLowerCase()}` : '';
+            const fileId = crypto_1.default.randomUUID();
+            const storageKey = `${projectId}/${category}/${fileId}${ext}`;
+            const collection = getRawFilesCollection();
+            if (collection) {
+                await collection.insertOne({
+                    _id: new mongodb_1.ObjectId(),
+                    fileId,
+                    projectId,
+                    storageConnectionId: connId,
+                    category,
+                    storageKey,
+                    displayName: fileName,
+                    contentType,
+                    uploadedBy: auth.userId,
+                    createdAt: new Date(),
+                });
+            }
+            const url = await connAdapter.getPresignedUploadUrl(storageKey, contentType);
+            res.json({ url, fileId, storageKey, displayName: fileName });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to generate upload URL', details: err.message });
+        }
+    });
+    router.get('/projects/:projectId/connections/storage/:connId/files/lasts', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId } = 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 access' });
+            const connAdapter = await resolveConnAdapter(connId, project, adapter);
+            if ('error' in connAdapter)
+                return res.status(connAdapter.status).json({ message: connAdapter.error });
+            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 data = await Promise.all(files.map(f => resolveFileUrl(f, connAdapter)));
+            res.json({ data });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch latest files', details: err.message });
+        }
+    });
+    router.get('/projects/:projectId/connections/storage/:connId/files/:category', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId, category } = req.params;
+            if (!VALID_CATEGORIES.includes(category)) {
+                return res.status(400).json({ message: `Invalid category. Must be one of: ${VALID_CATEGORIES.join(', ')}` });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.isProjectMember)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized access' });
+            const connAdapter = await resolveConnAdapter(connId, project, adapter);
+            if ('error' in connAdapter)
+                return res.status(connAdapter.status).json({ message: connAdapter.error });
+            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 data = await Promise.all(files.map(f => resolveFileUrl(f, connAdapter)));
+            res.json({ data });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to list files', details: err.message });
+        }
+    });
+    router.patch('/projects/:projectId/connections/storage/:connId/files/:fileId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId, fileId } = req.params;
+            const { displayName } = req.body;
+            if (!displayName || typeof displayName !== 'string') {
+                return res.status(400).json({ message: 'displayName 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 access' });
+            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' });
+            if (!result)
+                return res.status(404).json({ message: 'File not found' });
+            res.json({ message: 'File renamed successfully', file: result });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to rename file', details: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/connections/storage/:connId/files/:fileId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, connId, fileId } = 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 access' });
+            const connAdapter = await resolveConnAdapter(connId, project, adapter);
+            if ('error' in connAdapter)
+                return res.status(connAdapter.status).json({ message: connAdapter.error });
+            const collection = getRawFilesCollection();
+            if (!collection)
+                return res.status(500).json({ message: 'Database not available' });
+            const fileDoc = await collection.findOne(connFilter(projectId, connId, { 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 }));
+            res.json({ message: 'File deleted successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete file', details: err.message });
+        }
+    });
     router.get('/storages', async (_req, res) => {
         try {
             const STORAGE_DISPLAY = {

package/dist/middleware/routes/storageConnection.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import { StreamByConfig } from '../../types';
+export declare function storageConnectionRouter(config: StreamByConfig): Router;

package/dist/middleware/routes/storageConnection.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageConnectionRouter = storageConnectionRouter;
+const express_1 = require("express");
+const mongodb_1 = require("mongodb");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const VALID_STORAGE_TYPES = ['s3', 'gcs', 'r2', 'azure'];
+const STORAGE_DISPLAY = {
+    s3: 'AWS S3',
+    gcs: 'Google Cloud Storage',
+    r2: 'Cloudflare R2',
+    azure: 'Azure Blob Storage',
+};
+function storageConnectionRouter(config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // ─── List storage connections ─────────────────────────────────────────────
+    router.get('/projects/:id/connections/storage', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const project = await Project.findOne({ _id: req.params.id });
+            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 builtinConnections = (config.storageProviders || []).map((provider, i) => ({
+                id: i === 0 ? 'builtin' : `builtin-${i}`,
+                name: STORAGE_DISPLAY[provider.type] || provider.type,
+                type: provider.type,
+                credentialId: '',
+                projectId: req.params.id,
+                createdAt: new Date(0),
+                isBuiltin: true,
+            }));
+            const projectConnections = project.storageConnections || [];
+            return res.status(200).json({ data: [...builtinConnections, ...projectConnections] });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch storage connections', details: err.message });
+        }
+    });
+    // ─── Add storage connection ───────────────────────────────────────────────
+    router.post('/projects/:id/connections/storage', async (req, res) => {
+        try {
+            const auth = req.auth;
+            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' });
+            }
+            if (!VALID_STORAGE_TYPES.includes(type)) {
+                return res.status(400).json({ message: `type must be one of: ${VALID_STORAGE_TYPES.join(', ')}` });
+            }
+            const project = await Project.findOne({ _id: req.params.id });
+            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 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,
+                projectId: req.params.id,
+                createdAt: new Date(),
+                ...(description !== undefined && { description }),
+            };
+            await Project.update({ _id: req.params.id }, { $push: { storageConnections: connection } });
+            return res.status(201).json({ data: connection });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to add storage connection', details: err.message });
+        }
+    });
+    // ─── Delete storage connection ────────────────────────────────────────────
+    router.delete('/projects/:id/connections/storage/:connId', async (req, res) => {
+        try {
+            const { connId } = req.params;
+            if (connId === 'builtin' || connId.startsWith('builtin-')) {
+                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' });
+            }
+            const project = await Project.findOne({ _id: req.params.id });
+            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 exists = project.storageConnections?.some((c) => c.id === connId);
+            if (!exists)
+                return res.status(404).json({ message: 'Storage connection not found' });
+            await Project.update({ _id: req.params.id }, { $pull: { storageConnections: { id: connId } } });
+            return res.status(200).json({ message: 'Storage connection deleted successfully' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete storage connection', details: err.message });
+        }
+    });
+    return router;
+}

package/dist/models/Model.js

@@ -46,7 +46,7 @@ class Model {
                     const userId = processedFilter.members.$elemMatch.userId;
                     const schema = this.schema || 'streamby'; // Default to 'streamby' if schema not provided
                     const query = `
-            SELECT p.*, pm."userId" as memberUserId, pm.archived as memberArchived
+            SELECT p.*, pm."userId" as memberUserId, pm.role as memberRole, pm.status as memberStatus, pm.archived as memberArchived
             FROM "${schema}"."projects" p
             JOIN "${schema}"."project_members" pm ON p.id = pm."projectId"
             WHERE pm."userId" = $1
@@ -56,8 +56,9 @@ class Model {
                         ...row,
                         members: [{
                                 userId: row.memberUserId,
+                                role: row.memberRole,
+                                status: row.memberStatus,
                                 archived: row.memberArchived,
-                                // Add other member fields if necessary
                             }]
                     }));
                 }
@@ -72,7 +73,8 @@ class Model {
                         const projectMembers = await sql_1.sqlAdapter.find(connection, 'project_members', { projectId: transformedItem.id }, this.schema);
                         transformedItem.members = projectMembers.map((member) => ({
                             userId: member.userId,
-                            role: member.role, // Assuming role is also stored in project_members
+                            role: member.role,
+                            status: member.status,
                             archived: member.archived,
                         }));
                     }
@@ -122,7 +124,8 @@ class Model {
                         const projectMembers = await sql_1.sqlAdapter.find(connection, 'project_members', { projectId: transformedResult.id }, this.schema);
                         transformedResult.members = projectMembers.map((member) => ({
                             userId: member.userId,
-                            role: member.role, // Assuming role is also stored in project_members
+                            role: member.role,
+                            status: member.status,
                             archived: member.archived,
                         }));
                     }

package/dist/services/dbConnection.d.ts

@@ -5,7 +5,14 @@ export declare function listTablesOrCollections(connectionString: string, dbType
 export declare function createTableOrCollection(connectionString: string, dbType: ExternalDbType, schema: CreateTableSchema): Promise<void>;
 export declare function queryRecords(connectionString: string, dbType: ExternalDbType, tableName: string, limit?: number, offset?: number): Promise<any[]>;
 export declare function insertRecord(connectionString: string, dbType: ExternalDbType, tableName: string, record: Record<string, unknown>): Promise<any>;
+export declare function updateRecord(connectionString: string, dbType: ExternalDbType, tableName: string, recordId: string, updates: Record<string, unknown>): Promise<any | null>;
+export declare function deleteRecord(connectionString: string, dbType: ExternalDbType, tableName: string, recordId: string): Promise<boolean>;
 export declare function listTablesInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', projectId?: string): Promise<string[]>;
 export declare function queryRecordsInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', tableName: string, limit?: number, offset?: number, projectId?: string): Promise<any[]>;
+export declare function queryRecordByIdInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', tableName: string, recordId: string, projectId?: string): Promise<any | null>;
 export declare function createTableOrCollectionInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', schema: CreateTableSchema, projectId?: string): Promise<void>;
 export declare function insertRecordInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', tableName: string, record: Record<string, unknown>, projectId?: string): Promise<any>;
+export declare function updateRecordInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', tableName: string, recordId: string, updates: Record<string, unknown>, projectId?: string): Promise<any | null>;
+export declare function deleteRecordInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', tableName: string, recordId: string, projectId?: string): Promise<boolean>;
+export declare function deleteTableOrCollection(connectionString: string, dbType: ExternalDbType, tableName: string): Promise<void>;
+export declare function deleteTableOrCollectionInternal(client: Pool | MongoClient, dbType: 'sql' | 'nosql', tableName: string, projectId?: string): Promise<void>;

package/dist/services/dbConnection.js

@@ -1,13 +1,53 @@
 "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.listTablesOrCollections = listTablesOrCollections;
 exports.createTableOrCollection = createTableOrCollection;
 exports.queryRecords = queryRecords;
 exports.insertRecord = insertRecord;
+exports.updateRecord = updateRecord;
+exports.deleteRecord = deleteRecord;
 exports.listTablesInternal = listTablesInternal;
 exports.queryRecordsInternal = queryRecordsInternal;
+exports.queryRecordByIdInternal = queryRecordByIdInternal;
 exports.createTableOrCollectionInternal = createTableOrCollectionInternal;
 exports.insertRecordInternal = insertRecordInternal;
+exports.updateRecordInternal = updateRecordInternal;
+exports.deleteRecordInternal = deleteRecordInternal;
+exports.deleteTableOrCollection = deleteTableOrCollection;
+exports.deleteTableOrCollectionInternal = deleteTableOrCollectionInternal;
 const pg_1 = require("pg");
 const mongodb_1 = require("mongodb");
 // ─── Ephemeral connection helpers ─────────────────────────────────────────────
@@ -86,6 +126,50 @@ async function insertRecord(connectionString, dbType, tableName, record) {
         return { ...record, _id: result.insertedId };
     });
 }
+async function updateRecord(connectionString, dbType, tableName, recordId, updates) {
+    if (dbType === 'postgresql') {
+        return withPostgres(connectionString, async (client) => {
+            const keys = Object.keys(updates).filter(k => k !== 'id');
+            if (!keys.length)
+                return null;
+            const sets = keys.map((k, i) => `"${k}" = $${i + 1}`).join(', ');
+            const result = await client.query(`UPDATE "${tableName}" SET ${sets} WHERE id = $${keys.length + 1} RETURNING *`, [...keys.map(k => updates[k]), recordId]);
+            return result.rows[0] ?? null;
+        });
+    }
+    return withMongo(connectionString, async (db) => {
+        const { ObjectId } = await Promise.resolve().then(() => __importStar(require('mongodb')));
+        const { _id, ...fields } = updates;
+        let filter;
+        try {
+            filter = { _id: new ObjectId(recordId) };
+        }
+        catch {
+            filter = { _id: recordId };
+        }
+        return db.collection(tableName).findOneAndUpdate(filter, { $set: fields }, { returnDocument: 'after' });
+    });
+}
+async function deleteRecord(connectionString, dbType, tableName, recordId) {
+    if (dbType === 'postgresql') {
+        return withPostgres(connectionString, async (client) => {
+            const result = await client.query(`DELETE FROM "${tableName}" WHERE id = $1`, [recordId]);
+            return (result.rowCount ?? 0) > 0;
+        });
+    }
+    return withMongo(connectionString, async (db) => {
+        const { ObjectId } = await Promise.resolve().then(() => __importStar(require('mongodb')));
+        let filter;
+        try {
+            filter = { _id: new ObjectId(recordId) };
+        }
+        catch {
+            filter = { _id: recordId };
+        }
+        const result = await db.collection(tableName).deleteOne(filter);
+        return result.deletedCount > 0;
+    });
+}
 // ─── Internal (pool-based) variants ──────────────────────────────────────────
 // These operate on already-connected Pool / MongoClient from connectionManager.
 function quoteSqlTable(tableName) {
@@ -120,6 +204,23 @@ async function queryRecordsInternal(client, dbType, tableName, limit = 50, offse
     }
     return client.db().collection(fullName).find().limit(limit).skip(offset).toArray();
 }
+async function queryRecordByIdInternal(client, dbType, tableName, recordId, projectId) {
+    const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
+    if (dbType === 'sql') {
+        const result = await client.query(`SELECT * FROM ${quoteSqlTable(fullName)} WHERE id = $1 LIMIT 1`, [recordId]);
+        return result.rows[0] ?? null;
+    }
+    const db = client.db();
+    let doc = await db.collection(fullName).findOne({ _id: recordId });
+    if (!doc) {
+        try {
+            const { ObjectId } = await Promise.resolve().then(() => __importStar(require('mongodb')));
+            doc = await db.collection(fullName).findOne({ _id: new ObjectId(recordId) });
+        }
+        catch { /* invalid ObjectId format — not found */ }
+    }
+    return doc;
+}
 async function createTableOrCollectionInternal(client, dbType, schema, projectId) {
     const fullName = projectId ? `db_${projectId}_${schema.tableName}` : schema.tableName;
     if (dbType === 'sql') {
@@ -146,3 +247,58 @@ async function insertRecordInternal(client, dbType, tableName, record, projectId
     const result = await client.db().collection(fullName).insertOne(record);
     return { ...record, _id: result.insertedId };
 }
+async function updateRecordInternal(client, dbType, tableName, recordId, updates, projectId) {
+    const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
+    if (dbType === 'sql') {
+        const keys = Object.keys(updates).filter(k => k !== 'id');
+        if (!keys.length)
+            return null;
+        const sets = keys.map((k, i) => `"${k}" = $${i + 1}`).join(', ');
+        const result = await client.query(`UPDATE ${quoteSqlTable(fullName)} SET ${sets} WHERE id = $${keys.length + 1} RETURNING *`, [...keys.map(k => updates[k]), recordId]);
+        return result.rows[0] ?? null;
+    }
+    const { ObjectId } = await Promise.resolve().then(() => __importStar(require('mongodb')));
+    const { _id, ...fields } = updates;
+    let filter;
+    try {
+        filter = { _id: new ObjectId(recordId) };
+    }
+    catch {
+        filter = { _id: recordId };
+    }
+    return client.db().collection(fullName).findOneAndUpdate(filter, { $set: fields }, { returnDocument: 'after' });
+}
+async function deleteRecordInternal(client, dbType, tableName, recordId, projectId) {
+    const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
+    if (dbType === 'sql') {
+        const result = await client.query(`DELETE FROM ${quoteSqlTable(fullName)} WHERE id = $1`, [recordId]);
+        return (result.rowCount ?? 0) > 0;
+    }
+    const { ObjectId } = await Promise.resolve().then(() => __importStar(require('mongodb')));
+    let filter;
+    try {
+        filter = { _id: new ObjectId(recordId) };
+    }
+    catch {
+        filter = { _id: recordId };
+    }
+    const result = await client.db().collection(fullName).deleteOne(filter);
+    return result.deletedCount > 0;
+}
+async function deleteTableOrCollection(connectionString, dbType, tableName) {
+    if (dbType === 'postgresql') {
+        await withPostgres(connectionString, client => client.query(`DROP TABLE IF EXISTS "${tableName}"`).then(() => undefined));
+        return;
+    }
+    await withMongo(connectionString, async (db) => {
+        await db.dropCollection(tableName);
+    });
+}
+async function deleteTableOrCollectionInternal(client, dbType, tableName, projectId) {
+    const fullName = projectId ? `db_${projectId}_${tableName}` : tableName;
+    if (dbType === 'sql') {
+        await client.query(`DROP TABLE IF EXISTS ${quoteSqlTable(fullName)}`);
+        return;
+    }
+    await client.db().dropCollection(fullName);
+}

package/dist/services/export.d.ts

@@ -4,7 +4,7 @@ interface ExportResult {
     message: string;
 }
 export declare function createExport(config: StreamByConfig, projectId: string, description: string, exportName: string, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], nodeSchema?: NodeSchema, useConnections?: boolean, useCredentials?: boolean, storageDbId?: string): Promise<ExportResult>;
-export declare function updateExport(config: StreamByConfig, projectId: string, exportId: string, description: string, exportName: string, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], nodeSchema?: NodeSchema, useConnections?: boolean, useCredentials?: boolean): Promise<ExportResult>;
+export declare function updateExport(config: StreamByConfig, projectId: string, exportId: string, description: string, exportName: string, dbType: DatabaseType, exportType: 'json' | 'externalApi', isPrivate?: boolean, allowedOrigin?: string[], devMode?: boolean, devPorts?: number[], nodeSchema?: NodeSchema, useConnections?: boolean, useCredentials?: boolean): Promise<ExportResult>;
 export declare function deleteExport(config: StreamByConfig, projectId: string, exportId: string, dbType: DatabaseType, exportName: string): Promise<{
     message: string;
 }>;

package/dist/services/export.js

@@ -51,7 +51,7 @@ async function createExport(config, projectId, description, exportName, dbType,
     await ProjectModel.update({ _id: projectId }, { $push: { exports: exportEntry } });
     return { exportId, message: `${exportType} export created successfully` };
 }
-async function updateExport(config, projectId, exportId, description, exportName, dbType, exportType, isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials) {
+async function updateExport(config, projectId, exportId, description, exportName, dbType, exportType, isPrivate, allowedOrigin, devMode, devPorts, nodeSchema, useConnections, useCredentials) {
     // Resolve the project to find where its raw export data lives
     const Project = (0, manager_1.getModel)('projects');
     const project = await Project.findOne({ _id: projectId });
@@ -78,13 +78,13 @@ async function updateExport(config, projectId, exportId, description, exportName
         const SqlProject = (0, manager_1.getModel)('projects', 'sql');
         const currentExports = project?.exports ?? [];
         const updatedExports = currentExports.map((e) => String(e.id) === exportId
-            ? { ...e, name: exportName, private: isPrivate, allowedOrigin, nodeSchema, useConnections, useCredentials, description }
+            ? { ...e, name: exportName, private: isPrivate, allowedOrigin, devMode, devPorts, nodeSchema, useConnections, useCredentials, description }
             : e);
         await SqlProject.update({ _id: projectId }, { exports: updatedExports });
     }
     else {
         const NoSQLProject = (0, manager_1.getModel)('projects', 'nosql');
-        await NoSQLProject.update({ _id: new mongodb_1.ObjectId(projectId), 'exports.id': { $in: [new mongodb_1.ObjectId(exportId), exportId] } }, { $set: { 'exports.$.name': exportName, 'exports.$.private': isPrivate, 'exports.$.allowedOrigin': allowedOrigin, 'exports.$.nodeSchema': nodeSchema, 'exports.$.useConnections': useConnections, 'exports.$.useCredentials': useCredentials, 'exports.$.description': description } });
+        await NoSQLProject.update({ _id: new mongodb_1.ObjectId(projectId), 'exports.id': { $in: [new mongodb_1.ObjectId(exportId), exportId] } }, { $set: { 'exports.$.name': exportName, 'exports.$.private': isPrivate, 'exports.$.allowedOrigin': allowedOrigin, 'exports.$.devMode': devMode, 'exports.$.devPorts': devPorts, 'exports.$.nodeSchema': nodeSchema, 'exports.$.useConnections': useConnections, 'exports.$.useCredentials': useCredentials, 'exports.$.description': description } });
     }
     return { exportId, message: `${exportType} export updated successfully` };
 }

package/dist/services/pipeline.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executePipeline = executePipeline;
 const connectionManager_1 = require("../adapters/database/connectionManager");
 const encryption_1 = require("../utils/encryption");
+const dbConnection_1 = require("./dbConnection");
 function applyFilterConfig(payload, config) {
     const isArr = Array.isArray(payload);
     let r = isArr ? [...payload] : payload;
@@ -85,16 +86,27 @@ async function executePipeline(nodeSchema, project, config) {
             }
         }
         else if (node.type === 'dataSourceNode') {
-            const collectionName = node.data?.subtitle || node.data?.label;
-            if (!collectionName)
+            const tableName = (node.data?.tableName || node.data?.subtitle || node.data?.label);
+            if (!tableName)
                 continue;
-            const targetDb = config.databases?.find(db => db.type === project.dbType && db.main)
-                ?? config.databases?.find(db => db.type === project.dbType);
-            if (!targetDb)
-                throw new Error(`No database connection for type ${project.dbType}`);
-            const connection = (0, connectionManager_1.getConnection)(targetDb.id);
-            const db = connection.client.db();
-            dataResults.push(await db.collection(collectionName).find({}).toArray());
+            const connectionId = node.data?.connectionId;
+            const recordId = node.data?.recordId;
+            const fetchData = async (client, type) => recordId
+                ? (0, dbConnection_1.queryRecordByIdInternal)(client, type, tableName, recordId, project.id)
+                : (0, dbConnection_1.queryRecordsInternal)(client, type, tableName, 500, 0, project.id);
+            if (connectionId) {
+                const { client, type } = (0, connectionManager_1.getConnection)(connectionId);
+                dataResults.push(await fetchData(client, type));
+            }
+            else {
+                // legacy fallback for nodes saved before connectionId was introduced
+                const targetDb = config.databases?.find((db) => db.type === project.dbType && db.main)
+                    ?? config.databases?.find((db) => db.type === project.dbType);
+                if (!targetDb)
+                    throw new Error(`No database connection for type ${project.dbType}`);
+                const { client, type } = (0, connectionManager_1.getConnection)(targetDb.id);
+                dataResults.push(await fetchData(client, type));
+            }
         }
         else if (node.type === 'apiConnectionNode') {
             const apiConnection = project.apiConnections?.find((c) => c.id === node.data?.connectionId);

package/dist/types/index.d.ts

@@ -6,7 +6,18 @@ export interface S3Config {
     accessKeyId: string;
     secretAccessKey: string;
 }
-export type StorageProviderType = 's3';
+export type StorageProviderType = 's3' | 'gcs' | 'r2' | 'azure';
+export type StorageConnectionType = 's3' | 'gcs' | 'r2' | 'azure';
+export interface StorageConnection {
+    id: string;
+    name: string;
+    type: StorageConnectionType;
+    credentialId: string;
+    projectId: string;
+    createdAt: Date;
+    description?: string;
+    isBuiltin?: boolean;
+}
 export type StorageProvider = {
     type: StorageProviderType;
     config: S3Config;
@@ -60,6 +71,7 @@ export interface ProjectInfo {
     credentials?: Credential[];
     apiConnections?: ApiConnection[];
     dbConnections?: DbConnection[];
+    storageConnections?: StorageConnection[];
 }
 export interface Credential {
     id: string;

package/package.json

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