streamby-core 0.29.3 → 0.29.5

package/dist/middleware/createRouter.js

@@ -36,7 +36,24 @@ function createStreamByRouter(config) {
     const router = express_1.default.Router();
     if (config.encrypt)
         (0, encryption_1.setEncryptionKey)(config.encrypt);
-    (0, connectionManager_1.initConnections)(config.databases || []);
+    // Establish DB connections asynchronously (Postgres/Mongo + schema migrations).
+    // Until they're ready, HOLD incoming requests instead of letting them through —
+    // route handlers resolve projects/exports (e.g. the /menu-list export) against a
+    // live connection, so hitting them before startup finishes would 404. This gate
+    // makes the client's fetch wait for StreamBy's instances to come up.
+    let ready = false;
+    const readyPromise = (0, connectionManager_1.initConnections)(config.databases || [])
+        .catch((err) => {
+        console.error('❌ StreamBy: failed to initialize database connections:', err);
+    })
+        .finally(() => {
+        ready = true;
+    });
+    router.use((_req, _res, next) => {
+        if (ready)
+            return next();
+        readyPromise.then(() => next());
+    });
     const adapter = config.adapter || (0, storage_1.createStorageProvider)(config.storageProviders);
     if (config.databases) {
         const allDbIds = config.databases.map(db => db.id);

package/dist/middleware/routes/connection.js

@@ -102,6 +102,44 @@ function connectionRouter(config) {
             res.status(500).json({ message: 'Failed to add API connection', details: err.message });
         }
     });
+    // Update an API connection (name, url, method, prefix, credentialId, description)
+    router.patch('/projects/:id/connections/api/:connectionId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const { id: projectId, connectionId } = req.params;
+            const { name, apiUrl, method, description, credentialId, prefix } = req.body;
+            if (method && !VALID_METHODS.includes(method)) {
+                return res.status(400).json({ message: `method must be one of: ${VALID_METHODS.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 project access' });
+            }
+            if (credentialId) {
+                const credExists = project.credentials?.some((c) => c.id === credentialId);
+                if (!credExists) {
+                    return res.status(400).json({ message: 'Credential not found in project' });
+                }
+            }
+            const updated = await (0, apiConnection_1.updateApiConnection)(config, projectId, connectionId, {
+                ...(name !== undefined && { name }),
+                ...(apiUrl !== undefined && { apiUrl }),
+                ...(method !== undefined && { method }),
+                ...(description !== undefined && { description }),
+                ...(prefix !== undefined && { prefix }),
+                ...(credentialId !== undefined && { credentialId }),
+            });
+            return res.status(200).json({ data: updated });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to update API connection', details: err.message });
+        }
+    });
     // Execute the request represented by an API connection
     router.get('/projects/:id/get-connection/:connectionId', async (req, res) => {
         try {

package/dist/services/apiConnection.d.ts

@@ -7,4 +7,12 @@ export declare function addApiConnection(config: StreamByConfig, projectId: stri
     description?: string;
     credentialId?: string;
 }): Promise<ApiConnection>;
+export declare function updateApiConnection(config: StreamByConfig, projectId: string, connectionId: string, data: {
+    name?: string;
+    apiUrl?: string;
+    method?: ApiConnectionMethod;
+    prefix?: string;
+    description?: string;
+    credentialId?: string;
+}): Promise<ApiConnection>;
 export declare function deleteApiConnection(config: StreamByConfig, projectId: string, connectionId: string): Promise<void>;

package/dist/services/apiConnection.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addApiConnection = addApiConnection;
+exports.updateApiConnection = updateApiConnection;
 exports.deleteApiConnection = deleteApiConnection;
 const mongodb_1 = require("mongodb");
 const manager_1 = require("../models/manager");
@@ -27,6 +28,30 @@ async function addApiConnection(config, projectId, data) {
     }
     return connection;
 }
+async function updateApiConnection(config, projectId, connectionId, data) {
+    const ProjectModel = (0, manager_1.getModel)('projects');
+    const project = await ProjectModel.findOne({ _id: projectId });
+    if (!project)
+        throw new Error('Project not found.');
+    const connections = project.apiConnections ?? [];
+    const index = connections.findIndex((c) => c.id === connectionId);
+    if (index === -1)
+        throw new Error('API connection not found.');
+    const updated = {
+        ...connections[index],
+        ...(data.name !== undefined && { name: data.name }),
+        ...(data.apiUrl !== undefined && { apiUrl: data.apiUrl }),
+        ...(data.method !== undefined && { method: data.method }),
+        ...(data.prefix !== undefined && { prefix: data.prefix }),
+        ...(data.description !== undefined && { description: data.description }),
+        ...(data.credentialId !== undefined && { credentialId: data.credentialId }),
+    };
+    connections[index] = updated;
+    const result = await ProjectModel.update({ _id: projectId }, { $set: { apiConnections: connections } });
+    if (!result)
+        throw new Error('Failed to update API connection.');
+    return updated;
+}
 async function deleteApiConnection(config, projectId, connectionId) {
     const ProjectModel = (0, manager_1.getModel)('projects');
     const project = await ProjectModel.findOne({ _id: projectId });

package/package.json

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