streamby-core 0.37.0 → 0.39.0

package/dist/mcp/workflowNodes.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newShotNode = void 0;
+exports.ensureWorkflowNode = ensureWorkflowNode;
+const crypto_1 = __importDefault(require("crypto"));
+const manager_1 = require("../models/manager");
+const auth_1 = require("../utils/auth");
+const auth_2 = require("../services/auth");
+// The node types that make a workflow's production section (as the UI groups them).
+const PRODUCTION_NODE_TYPES = new Set(['shotNode', 'assemblyNode', 'masterNode']);
+/** A Shot node, as the UI makes one dropped on the canvas without a position. */
+const newShotNode = () => ({
+    id: `shotNode-${crypto_1.default.randomUUID()}`,
+    type: 'shotNode',
+    position: { x: 240 + Math.random() * 60, y: 300 + Math.random() * 40 },
+    data: { label: 'Shot', subtitle: 'Raw video clip', bgColor: '#0e2537', iconColor: '#38B6FF' },
+});
+exports.newShotNode = newShotNode;
+/**
+ * Makes sure a project's workflow has what `requirement` needs, adding it (through the REST
+ * API, as the caller) if it's missing. An error to answer with, or null to go on. A project
+ * the caller doesn't reach is left alone: the call that follows answers for it.
+ */
+async function ensureWorkflowNode(requirement, projectId, auth, api) {
+    if (requirement !== 'production' || !projectId)
+        return null;
+    if (!(0, auth_2.scopeReachesProject)(auth.apiToken, projectId))
+        return null;
+    const project = await (0, manager_1.getModel)('projects').findOne({ _id: projectId });
+    if (!project || !(0, auth_1.activeMemberOf)(project, auth.userId))
+        return null;
+    const schema = project.workflow?.nodeSchema ?? null;
+    const nodes = Array.isArray(schema?.nodes) ? schema.nodes : [];
+    if (nodes.some(node => PRODUCTION_NODE_TYPES.has(node?.type)))
+        return null;
+    const answer = await api({
+        method: 'PATCH',
+        path: `/projects/${encodeURIComponent(projectId)}/workflow`,
+        body: { nodeSchema: { ...(schema ?? {}), nodes: [...nodes, (0, exports.newShotNode)()], edges: Array.isArray(schema?.edges) ? schema.edges : [] } },
+    });
+    if (answer.status >= 200 && answer.status < 300)
+        return null;
+    const message = answer.body?.message ?? answer.body?.error;
+    return `Couldn't add a production node to the project's workflow: ${typeof message === 'string' ? message : `StreamBy answered ${answer.status}`}`;
+}

package/dist/middleware/createRouter.js

@@ -38,6 +38,7 @@ const production_1 = require("./routes/production");
 const rights_1 = require("./routes/rights");
 const workflow_1 = require("./routes/workflow");
 const pipeline_1 = require("./routes/pipeline");
+const deliverable_1 = require("./routes/deliverable");
 function createStreamByRouter(config) {
     const router = express_1.default.Router();
     if (config.encrypt)
@@ -134,5 +135,6 @@ function createStreamByRouter(config) {
     router.use((0, rights_1.rightsRouter)(config));
     router.use((0, workflow_1.workflowRouter)(config));
     router.use((0, pipeline_1.pipelineRouter)(config));
+    router.use((0, deliverable_1.deliverableRouter)(config));
     return router;
 }

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

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

package/dist/middleware/routes/apiConnection.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiConnectionRouter = apiConnectionRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const apiConnection_1 = require("../../services/apiConnection");
+const VALID_METHODS = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE'];
+function apiConnectionRouter(config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // List API connections for a project
+    router.get('/projects/:id/api/connections', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const projectId = req.params.id;
+            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' });
+            }
+            return res.status(200).json({ data: project.apiConnections || [] });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch API connections', details: err.message });
+        }
+    });
+    // Add a new API connection to a project
+    router.post('/projects/:id/api/connections', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const { name, baseUrl, method, description, credentialId, prefix } = req.body;
+            if (!name || !baseUrl) {
+                return res.status(400).json({ message: 'name and baseUrl are required' });
+            }
+            if (!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 connection = await (0, apiConnection_1.addApiConnection)(config, projectId, {
+                name,
+                baseUrl,
+                method,
+                prefix,
+                ...(description !== undefined && { description }),
+                ...(credentialId !== undefined && { credentialId }),
+            });
+            return res.status(201).json({ data: connection });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to add API connection', details: err.message });
+        }
+    });
+    // Delete an API connection from a project
+    router.delete('/projects/:id/api/connections/:connectionId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            if (auth.role !== 'admin' && auth.role !== 'editor') {
+                return res.status(403).json({ message: 'Permission denied' });
+            }
+            const projectId = req.params.id;
+            const { connectionId } = 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 exists = project.apiConnections?.some((c) => c.id === connectionId);
+            if (!exists) {
+                return res.status(404).json({ message: 'API connection not found' });
+            }
+            await (0, apiConnection_1.deleteApiConnection)(config, projectId, connectionId);
+            return res.status(200).json({ message: 'API connection deleted successfully.' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete API connection', details: err.message });
+        }
+    });
+    return router;
+}

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

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

package/dist/middleware/routes/credential.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.credentialRouter = credentialRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const sanitize_1 = require("../../utils/sanitize");
+const credential_1 = require("../../services/credential");
+function credentialRouter(config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    // Add a new credential to a project
+    router.post('/projects/:id/credentials', 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 { id, key, value } = req.body;
+            if (!key || !value) {
+                return res.status(400).json({ message: 'Missing credential key or value' });
+            }
+            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' });
+            }
+            const updatedProject = await (0, credential_1.addCredential)(config, projectId, { id, key, value });
+            res.status(201).json({ message: 'Credential added successfully', project: (0, sanitize_1.sanitizeProject)(updatedProject) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to add credential', details: err.message });
+        }
+    });
+    // Update an existing credential in a project
+    router.patch('/projects/:id/credentials/:credentialId', 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 credentialId = req.params.credentialId;
+            const { key, value } = req.body;
+            if (!key && !value) {
+                return res.status(400).json({ message: 'No update fields provided' });
+            }
+            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' });
+            }
+            const updatedProject = await (0, credential_1.updateCredential)(config, projectId, credentialId, { key, value });
+            res.status(200).json({ message: 'Credential updated successfully', project: (0, sanitize_1.sanitizeProject)(updatedProject) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to update credential', details: err.message });
+        }
+    });
+    // Delete a credential from a project
+    router.delete('/projects/:id/credentials/:credentialId', 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 credentialId = req.params.credentialId;
+            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' });
+            }
+            const updatedProject = await (0, credential_1.deleteCredential)(config, projectId, credentialId);
+            res.status(200).json({ message: 'Credential deleted successfully', project: (0, sanitize_1.sanitizeProject)(updatedProject) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to delete credential', details: err.message });
+        }
+    });
+    return router;
+}

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

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

package/dist/middleware/routes/deliverable.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deliverableRouter = deliverableRouter;
+const express_1 = require("express");
+const manager_1 = require("../../models/manager");
+const auth_1 = require("../../utils/auth");
+const nosqlDb_1 = require("../../utils/nosqlDb");
+const assetVersions_1 = require("../../services/assetVersions");
+const deliverables_1 = require("../../services/deliverables");
+const MAX_NOTE = 1000;
+// A project's deliverables (see services/deliverables): marked, listed and removed. Removing
+// one never deletes its asset.
+function deliverableRouter(_config) {
+    const router = (0, express_1.Router)();
+    const Project = (0, manager_1.getModel)('projects');
+    const exportsOf = (project) => project.exports ?? [];
+    // What a list shows of each: its asset's name and kind, its version's number, and the name
+    // of the shot or export it's for.
+    const describe = async (project, deliverables) => {
+        const db = (0, nosqlDb_1.nosqlDb)();
+        const assetIds = [...new Set(deliverables.map(d => d.assetId))];
+        const shotIds = [...new Set(deliverables.map(d => d.shotId).filter(Boolean))];
+        const versionIds = [...new Set(deliverables.map(d => d.versionId).filter(Boolean))];
+        const [files, shots, versions] = db
+            ? await Promise.all([
+                db.collection('storage_files').find({ projectId: project._id?.toString() ?? project.id, fileId: { $in: assetIds } }).toArray(),
+                shotIds.length ? db.collection('production_shots').find({ id: { $in: shotIds } }).toArray() : [],
+                versionIds.length ? db.collection('asset_versions').find({ versionId: { $in: versionIds } }).toArray() : [],
+            ])
+            : [[], [], []];
+        return deliverables.map(d => {
+            const file = files.find((f) => f.fileId === d.assetId);
+            const version = versions.find((v) => v.versionId === d.versionId);
+            return {
+                ...d,
+                asset: file ? { displayName: file.displayName, category: file.category, contentType: file.contentType ?? null } : null,
+                version: version ? version.version : null,
+                shotName: d.shotId ? shots.find((s) => s.id === d.shotId)?.name ?? null : null,
+                exportName: d.exportId ? exportsOf(project).find((e) => e.id?.toString() === d.exportId)?.name ?? null : null,
+            };
+        });
+    };
+    router.get('/projects/:projectId/deliverables', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { shotId, exportId } = req.query;
+            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' });
+            const deliverables = await (0, deliverables_1.listDeliverables)(projectId, { shotId, exportId });
+            res.json({ deliverables: await describe(project, deliverables) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to list deliverables', details: err.message });
+        }
+    });
+    router.post('/projects/:projectId/deliverables', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId } = req.params;
+            const { assetId, versionId, shotId, exportId, note } = req.body ?? {};
+            if (typeof assetId !== 'string' || !assetId)
+                return res.status(400).json({ message: 'assetId is required' });
+            if (versionId !== undefined && versionId !== null && typeof versionId !== 'string') {
+                return res.status(400).json({ message: 'versionId must be a string' });
+            }
+            const forShot = typeof shotId === 'string' && shotId !== '';
+            const forExport = typeof exportId === 'string' && exportId !== '';
+            if (forShot === forExport)
+                return res.status(400).json({ message: 'A deliverable is for a shot (shotId) or for an export (exportId), one of them' });
+            if (note !== undefined && note !== null && (typeof note !== 'string' || note.length > MAX_NOTE)) {
+                return res.status(400).json({ message: `note must be a string of at most ${MAX_NOTE} characters` });
+            }
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.canEditProject)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            const db = (0, nosqlDb_1.nosqlDb)();
+            if (!db)
+                return res.status(500).json({ message: 'Database not available' });
+            if (!(await db.collection('storage_files').findOne({ fileId: assetId, projectId }))) {
+                return res.status(404).json({ message: 'Asset not found' });
+            }
+            if (versionId && !(await (0, assetVersions_1.findVersion)(projectId, assetId, versionId))) {
+                return res.status(404).json({ message: 'Version not found' });
+            }
+            if (forShot && !(await db.collection('production_shots').findOne({ id: shotId, projectId }))) {
+                return res.status(404).json({ message: 'Shot not found' });
+            }
+            if (forExport && !exportsOf(project).some((e) => e.id?.toString() === exportId)) {
+                return res.status(404).json({ message: 'Export not found' });
+            }
+            const deliverable = await (0, deliverables_1.createDeliverable)({
+                projectId,
+                assetId,
+                versionId: versionId || null,
+                shotId: forShot ? shotId : null,
+                exportId: forExport ? exportId : null,
+                note: note || null,
+                createdBy: auth.userId,
+            });
+            const [described] = await describe(project, [deliverable]);
+            res.status(201).json({ deliverable: described });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to mark the deliverable', details: err.message });
+        }
+    });
+    router.delete('/projects/:projectId/deliverables/:deliverableId', async (req, res) => {
+        try {
+            const auth = req.auth;
+            const { projectId, deliverableId } = req.params;
+            const project = await Project.findOne({ _id: projectId });
+            if (!project)
+                return res.status(404).json({ message: 'Project not found' });
+            if (!(0, auth_1.canEditProject)(project, auth.userId))
+                return res.status(403).json({ message: 'Unauthorized' });
+            if (!(await (0, deliverables_1.deleteDeliverable)(projectId, deliverableId)))
+                return res.status(404).json({ message: 'Deliverable not found' });
+            res.json({ message: 'Deliverable removed' });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to remove the deliverable', details: err.message });
+        }
+    });
+    return router;
+}

package/dist/middleware/routes/export.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exportRouter = exportRouter;
 const express_1 = require("express");
+const deliverables_1 = require("../../services/deliverables");
+const sanitize_1 = require("../../utils/sanitize");
 const manager_1 = require("../../models/manager");
 const auth_1 = require("../../utils/auth");
 const export_1 = require("../../services/export");
@@ -60,6 +62,21 @@ const DEFAULT_NODE_SCHEMA = {
 function exportRouter(config) {
     const router = (0, express_1.Router)();
     const Project = (0, manager_1.getModel)('projects');
+    // ─── A project's exports, on their own ────────────────────────────────────
+    router.get('/projects/:id/exports', 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 access' });
+            return res.status(200).json({ data: (0, sanitize_1.exportSummaries)(project.exports) });
+        }
+        catch (err) {
+            res.status(500).json({ message: 'Failed to fetch exports', details: err.message });
+        }
+    });
     router.get('/projects/:id/exports/:export_id', async (req, res) => {
         try {
             const auth = await config.authProvider(req);
@@ -292,6 +309,7 @@ function exportRouter(config) {
                 return res.status(404).json({ message: 'Export not found in this project' });
             }
             await (0, export_1.deleteExport)(config, projectId, exportId, project.dbType);
+            await (0, deliverables_1.deleteDeliverablesOf)(projectId, { exportId });
             res.status(200).json({ message: 'Export deleted successfully' });
         }
         catch (err) {